Merge branch 'master' of git.xpub.nl:/var/www/git.xpub.nl/repos/OuNoPo-make

Makefile

@@ -88,10 +88,13 @@ output/chatbot.txt: ocr/output.txt ## Comments a text with a simple chatbot. Dep
 output/n7.txt: ocr/output.txt ## Replaces nouns with the 7th noun that follows. Dependencies: 91k_nouns
 	cat $< | python3 src/n_7.py > $(@)
 
-output/carlandre.txt: ocr/output.txt ## Creates visual poetry out of a text. Dependencies
+output/carlandre.txt: ocr/output.txt ## Alice: Creates visual poetry out of a text. Dependencies: pytest
 	cat $< | python3 src/carlandre.py > $(@)
 # cat $(@) > /dev/usb/lp0
 
+output/overunder.txt: ocr/output.txt ## Alice: An interpreted language that translate simple weaving instructions and creates a weaving pattern on text. Dependencies: 
+	cat $< | python3 src/overunder.py > $(@)
+
 
 visualization: $(images) $(tmpfile) ##Creates data visualization from images/*.jpg. Dependencies: mplayer
 	@echo $(tmpfile)

ocr/list.txt

@@ -0,0 +1,4 @@
+
+images/*-0.jpg
+images/*-1.jpg
+

ocr/output.txt

@@ -0,0 +1,13 @@
+apparatus of Greece. the logic of its
+organisation becomes clear. In that respect, it
+is not the utopian proposal. Plato claimed that
+instead of over~dramatisatlon of reality.
+educational system should provide a clear
+description of reality. According to Plato that is
+precisely what philosophy Is doing. Who should
+therefor rule people‘s hearts and minds?
+Philosophers or poets? It was a power struggle
+between philosophers and poets. Poetry stood
+in Plato's way to propagate Platonism.
+
+

src/carlandre.py

@@ -0,0 +1,129 @@
+import pytest
+from math import ceil
+import sys
+from sys import stdout
+import time
+import os.path
+
+
+def pop_items(words, num_items):
+    ''' Removes num_items from words.'''
+    if not words:
+         return [], []
+
+    if num_items > len(words):
+        raise ValueError('Not enough items!')
+
+    popped = []
+    for number in range(num_items):
+        removed = words.pop(0)
+        popped.append(removed)
+    return popped, words
+
+def all_words_less_than(words, maxlength):
+    ''' Checks if the words have the correct length given in maxlength'''
+    for word in words:
+        if len(word) > maxlength:
+            return False
+    return True
+
+def filterwords(words, maxlength):
+    ''' Puts the words which have the correct length in a new list '''
+    goodwords = []
+    for word in words:
+        if len(word) <= maxlength and len(word) >=2:
+            goodwords.append(word)
+    return goodwords
+
+
+def pattern(words, maxlength):
+    goodwords = filterwords(words, maxlength)
+    items_pattern = maxlength + (maxlength -4)
+
+    if len(goodwords) % items_pattern != 0:
+        rest = len(goodwords) % items_pattern
+        difference = len(goodwords) - rest
+        goodwords = goodwords[:difference]
+
+    times = int(len(words) / items_pattern)
+
+    final_pattern = []
+    for each_time in range(times):
+        popped, whatisleft = pop_items(goodwords, items_pattern)
+        if not popped:
+            continue
+        goodwords = whatisleft
+
+        middle = ceil(len(popped)/2)
+
+        ascending = sorted(popped[:middle], key=len)
+        descending = sorted(popped[middle:], key=len, reverse=True)
+
+
+        sorted_pattern = ascending + descending
+        final_pattern.append(sorted_pattern)
+
+    return final_pattern
+
+
+def test_pattern_returns_list():
+    list_items = ['a', 'b', 'c', 'd', 'e']
+    assert type(pattern(list_items, 3)) == type([])
+
+def test_pattern_removes_over_max_len():
+    list_words_right_length = [['a', 'aa', 'aaa', 'aa', 'a']]
+    words_wrong_length = list_words_right_length[0] + ['aaaaa']
+    assert pattern(words_wrong_length, 3) == list_words_right_length
+
+def test_pop_items():
+    assert pop_items(['a', 'aaa'], 1) == (['a'], ['aaa'])
+
+def test_pop_items_empty_list():
+    assert pop_items([], 70) == ([], [])
+
+def test_pop_items_num_too_big():
+    with pytest.raises(ValueError):
+        pop_items(['a', 'b'], 3)
+
+def test_cuts_for_pattern():
+    list_with_nine = ['a'] * 9
+    result = pattern(list_with_nine, 3)
+    assert len(result[0]) == 5
+
+def test_empty_list_for_pattern():
+    result = pattern([], 3)
+    assert result == []
+
+def test_list_too_short_for_pattern():
+    list_too_short = ['a', 'aa']
+    result = pattern(list_too_short, 3)
+    assert result == []
+
+if __name__ == '__main__':
+    with open('ocr/output.txt', 'r') as handle:
+        contents = handle.read()
+    splitted = contents.split()
+    ll = (pattern(splitted, 8))
+    my_list = []
+    for l in ll:
+        for x in l:
+            my_list.append(x)
+    joined_list = '\n'.join(my_list)
+
+
+
+my_path = '/dev/usb/lp0'
+if os.path.exists(my_path):
+    sys.stdout = open(my_path, 'w')
+
+
+
+escpos = {
+    "init_printer":  "\x1B\x40",
+    'papercut':'\x1D\x56\x00',
+}
+
+for i in range(10):
+    print(escpos['init_printer'])
+    print(joined_list)
+    print(escpos['papercut'])

src/overunder.py

@@ -0,0 +1,90 @@
+import linecache
+import textwrap
+import sys
+from sys import exit
+
+class LeavingProgram(Exception):
+    pass
+
+def parse(program):
+    cmds = program.split(',')
+    splitted_cmds = []
+    for cmd in cmds:
+        splitted = cmd.split()
+        splitted_cmds.append(splitted)
+    return splitted_cmds
+
+    #return tokenize(program)
+def tokenize(s):
+    return s.split()
+
+def repl():
+    while True:
+        try:
+            val = eval(parse(input('> ')))
+            if val is not None:
+                print(val)
+        except LeavingProgram:
+            break
+
+text = None
+line_number = 0
+last_index = 0
+
+
+def eval(cmds):
+    global text
+    global line_number
+    global last_index
+
+    for cmd in cmds:
+        if cmd == []:
+            line_number += 1
+            last_index = 0
+
+        elif cmd[0] == 'load':
+            contents = open('output.txt').read()
+            text = textwrap.wrap(contents, 40, break_long_words=True)
+            print('\n'.join(text))
+            line_number = 0
+            last_index = 0
+
+        elif cmd[0] == 'show':
+            print(text[line_number])
+
+        elif cmd[0] == 'under':
+            current_line = text[line_number]
+            char_number = int(cmd[1]) - 1
+            char_list = list(current_line)
+
+            x=range(last_index, char_number + last_index + 1)
+            for time in x:
+                if time < len(char_list):
+                    char_list[time] = u'\u21e2'
+
+            last_index += char_number + 1
+
+            joined = ''.join(char_list)
+            text[line_number] = joined
+
+        elif cmd[0] == 'over':
+            last_index += int(cmd[1])
+
+        elif cmd[0] == 'pattern':
+
+            pattern = text[0:line_number + 1]
+            print('\n'.join(pattern))
+
+
+        elif cmd[0] == 'quit':
+            print('Come back soon!')
+            raise LeavingProgram()
+        else:
+            joined = ' '.join(cmd)
+            print('Did not understand command {}'.format(joined))
+
+
+
+
+if __name__ == '__main__':
+    repl()