def test_reverse_lookup(self): dc = StenoDictionaryCollection() d1 = StenoDictionary() d1[('PWAOUFL',)] = 'beautiful' d1[('WAOUFL',)] = 'beautiful' d2 = StenoDictionary() d2[('PW-FL',)] = 'beautiful' d3 = StenoDictionary() d3[('WAOUFL',)] = 'not beautiful' # Simple test. dc.set_dicts([d1]) self.assertCountEqual(dc.reverse_lookup('beautiful'), [('PWAOUFL',), ('WAOUFL',)]) # No duplicates. d2_copy = StenoDictionary() d2_copy.update(d2) dc.set_dicts([d2_copy, d2]) self.assertCountEqual(dc.reverse_lookup('beautiful'), [('PW-FL',)]) # Don't stop at the first dictionary with matches. dc.set_dicts([d2, d1]) self.assertCountEqual(dc.reverse_lookup('beautiful'), [('PWAOUFL',), ('WAOUFL',), ('PW-FL',)]) # Ignore keys overriden by a higher precedence dictionary. dc.set_dicts([d3, d2, d1]) self.assertCountEqual(dc.reverse_lookup('beautiful'), [('PWAOUFL',), ('PW-FL',)])
def test_dictionary_collection(self): dc = StenoDictionaryCollection() d1 = StenoDictionary() d1[('S', )] = 'a' d1[('T', )] = 'b' d2 = StenoDictionary() d2[('S', )] = 'c' d2[('W', )] = 'd' dc.set_dicts([d1, d2]) self.assertEqual(dc.lookup(('S', )), 'c') self.assertEqual(dc.lookup(('W', )), 'd') self.assertEqual(dc.lookup(('T', )), 'b') f = lambda k, v: v == 'c' dc.add_filter(f) self.assertIsNone(dc.lookup(('S', ))) self.assertEqual(dc.raw_lookup(('S', )), 'c') self.assertEqual(dc.lookup(('W', )), 'd') self.assertEqual(dc.lookup(('T', )), 'b') self.assertEqual(dc.reverse_lookup('c'), [('S', )]) dc.remove_filter(f) self.assertEqual(dc.lookup(('S', )), 'c') self.assertEqual(dc.lookup(('W', )), 'd') self.assertEqual(dc.lookup(('T', )), 'b') self.assertEqual(dc.reverse_lookup('c'), [('S', )]) dc.set(('S', ), 'e') self.assertEqual(dc.lookup(('S', )), 'e') self.assertEqual(d2[('S', )], 'e')
def test_dictionary_collection_longest_key(self): k1 = ('S',) k2 = ('S', 'T') k3 = ('S', 'T' , 'R') dc = StenoDictionaryCollection() self.assertEqual(dc.longest_key, 0) d1 = StenoDictionary() d1._path = 'd1' d1.save = lambda: None d1[k1] = 'a' dc.set_dicts([d1]) self.assertEqual(dc.longest_key, 1) d1[k2] = 'a' self.assertEqual(dc.longest_key, 2) d2 = StenoDictionary() d2._path = 'd2' d2[k3] = 'c' dc.set_dicts([d1, d2]) self.assertEqual(dc.longest_key, 3) del d1[k2] self.assertEqual(dc.longest_key, 3) dc.set_dicts([d1]) self.assertEqual(dc.longest_key, 1) dc.set_dicts([]) self.assertEqual(dc.longest_key, 0)
def test_dictionary_collection_longest_key(): k1 = ('S',) k2 = ('S', 'T') k3 = ('S', 'T', 'R') dc = StenoDictionaryCollection() assert dc.longest_key == 0 d1 = StenoDictionary() d1.path = 'd1' d1[k1] = 'a' dc.set_dicts([d1]) assert dc.longest_key == 1 d1[k2] = 'a' assert dc.longest_key == 2 d2 = StenoDictionary() d2.path = 'd2' d2[k3] = 'c' dc.set_dicts([d2, d1]) assert dc.longest_key == 3 del d1[k2] assert dc.longest_key == 3 dc.set_dicts([d1]) assert dc.longest_key == 1 dc.set_dicts([]) assert dc.longest_key == 0
def test_reverse_lookup(self): dc = StenoDictionaryCollection() d1 = StenoDictionary() d1[('PWAOUFL', )] = 'beautiful' d1[('WAOUFL', )] = 'beautiful' d2 = StenoDictionary() d2[('PW-FL', )] = 'beautiful' d3 = StenoDictionary() d3[('WAOUFL', )] = 'not beautiful' # Simple test. dc.set_dicts([d1]) assertCountEqual(self, dc.reverse_lookup('beautiful'), [('PWAOUFL', ), ('WAOUFL', )]) # No duplicates. dc.set_dicts([d2, StenoDictionary(d2)]) assertCountEqual(self, dc.reverse_lookup('beautiful'), [('PW-FL', )]) # Don't stop at the first dictionary with matches. dc.set_dicts([d1, d2]) assertCountEqual(self, dc.reverse_lookup('beautiful'), [('PWAOUFL', ), ('WAOUFL', ), ('PW-FL', )]) # Ignore keys overriden by a higher precedence dictionary. dc.set_dicts([d1, d2, d3]) assertCountEqual(self, dc.reverse_lookup('beautiful'), [('PWAOUFL', ), ('PW-FL', )])
def test_casereverse_del(self): d = StenoDictionary() d[('S-G',)] = 'something' d[('SPH-G',)] = 'something' self.assertEqual(d.casereverse_lookup('something'), ['something']) del d[('S-G',)] self.assertEqual(d.casereverse_lookup('something'), ['something']) del d[('SPH-G',)] self.assertEqual(d.casereverse_lookup('something'), [])
def test_casereverse_del(): d = StenoDictionary() d[('S-G', )] = 'something' d[('SPH-G', )] = 'something' assert d.casereverse_lookup('something') == ['something'] del d[('S-G', )] assert d.casereverse_lookup('something') == ['something'] del d[('SPH-G', )] assert d.casereverse_lookup('something') == []
def test_casereverse_del(self): d = StenoDictionary() d[('S-G', )] = 'something' d[('SPH-G', )] = 'something' self.assertEqual(d.casereverse_lookup('something'), ['something']) del d[('S-G', )] self.assertEqual(d.casereverse_lookup('something'), ['something']) del d[('SPH-G', )] self.assertEqual(d.casereverse_lookup('something'), [])
def test_casereverse_del(): d = StenoDictionary() d[('S-G',)] = 'something' d[('SPH-G',)] = 'something' assert d.casereverse_lookup('something') == ['something'] del d[('S-G',)] assert d.casereverse_lookup('something') == ['something'] del d[('SPH-G',)] assert d.casereverse_lookup('something') == []
def setUp(self): self.output = CaptureOutput() self.formatter = Formatter() self.formatter.set_output(self.output) self.translator = Translator() self.translator.add_listener(self.formatter.format) self.dictionary = self.translator.get_dictionary() dictionary = StenoDictionary() dictionary.save = lambda: None self.dictionary.set_dicts([dictionary])
def test_dictionary_collection_writeable(self): d1 = StenoDictionary() d1[('S',)] = 'a' d1[('T',)] = 'b' d2 = StenoDictionary() d2[('S',)] = 'c' d2[('W',)] = 'd' d2.readonly = True dc = StenoDictionaryCollection([d2, d1]) self.assertEqual(dc.first_writable(), d1) dc.set(('S',), 'A') self.assertEqual(d1[('S',)], 'A') self.assertEqual(d2[('S',)], 'c')
def test_dictionary_collection_writeable(): d1 = StenoDictionary() d1[('S', )] = 'a' d1[('T', )] = 'b' d2 = StenoDictionary() d2[('S', )] = 'c' d2[('W', )] = 'd' d2.readonly = True dc = StenoDictionaryCollection([d2, d1]) assert dc.first_writable() == d1 dc.set(('S', ), 'A') assert d1[('S', )] == 'A' assert d2[('S', )] == 'c'
def test_dictionary_collection_writeable(self): d1 = StenoDictionary() d1[('S', )] = 'a' d1[('T', )] = 'b' d2 = StenoDictionary() d2[('S', )] = 'c' d2[('W', )] = 'd' d2.readonly = True dc = StenoDictionaryCollection([d2, d1]) self.assertEqual(dc.first_writable(), d1) dc.set(('S', ), 'A') self.assertEqual(d1[('S', )], 'A') self.assertEqual(d2[('S', )], 'c')
def test_dictionary_collection_writeable(): d1 = StenoDictionary() d1[('S',)] = 'a' d1[('T',)] = 'b' d2 = StenoDictionary() d2[('S',)] = 'c' d2[('W',)] = 'd' d2.readonly = True dc = StenoDictionaryCollection([d2, d1]) assert dc.first_writable() == d1 dc.set(('S',), 'A') assert d1[('S',)] == 'A' assert d2[('S',)] == 'c'
def test_dictionary(): d = StenoDictionary() assert len(d) == 0 assert not d d['S'] = 'a' assert 'S' in d assert len(d) == 1 assert d d['S/S/S/S'] = 'b' assert len(d) == 2 d['S/S'] = 'c' assert d['S/S'] == 'c' assert len(d) == 3 del d['S/S/S/S'] assert len(d) == 2 del d['S'] assert 'S' not in d assert len(d) == 1 assert d.reverse_lookup('c') == ['S/S'] assert d.casereverse_lookup('c') == ['c'] d.clear() assert len(d) == 0 assert not d assert d.reverse_lookup('c') == [] assert d.casereverse_lookup('c') == [] d['S/S'] = 'c'
def test_dictionary_enabled(self): dc = StenoDictionaryCollection() d1 = StenoDictionary() d1.path = 'd1' d1[('TEFT', )] = 'test1' d1[('TEFGT', )] = 'Testing' d2 = StenoDictionary() d2[('TEFT', )] = 'test2' d2[('TEFT', '-G')] = 'Testing' d2.path = 'd2' dc.set_dicts([d2, d1]) self.assertEqual(dc.lookup(('TEFT', )), 'test2') self.assertEqual(dc.raw_lookup(('TEFT', )), 'test2') self.assertEqual(dc.casereverse_lookup('testing'), ['Testing']) self.assertCountEqual(dc.reverse_lookup('Testing'), [('TEFGT', ), ('TEFT', '-G')]) d2.enabled = False self.assertEqual(dc.lookup(('TEFT', )), 'test1') self.assertEqual(dc.raw_lookup(('TEFT', )), 'test1') self.assertEqual(dc.casereverse_lookup('testing'), ['Testing']) self.assertCountEqual(dc.reverse_lookup('Testing'), [('TEFGT', )]) d1.enabled = False self.assertEqual(dc.lookup(('TEST', )), None) self.assertEqual(dc.raw_lookup(('TEFT', )), None) self.assertEqual(dc.casereverse_lookup('testing'), None) self.assertCountEqual(dc.reverse_lookup('Testing'), [])
def test_dictionary_enabled(): dc = StenoDictionaryCollection() d1 = StenoDictionary() d1.path = 'd1' d1[('TEFT', )] = 'test1' d1[('TEFGT', )] = 'Testing' d2 = StenoDictionary() d2[('TEFT', )] = 'test2' d2[('TEFT', '-G')] = 'Testing' d2.path = 'd2' dc.set_dicts([d2, d1]) assert dc.lookup(('TEFT', )) == 'test2' assert dc.raw_lookup(('TEFT', )) == 'test2' assert dc.casereverse_lookup('testing') == ['Testing'] assert dc.reverse_lookup('Testing') == {('TEFT', '-G'), ('TEFGT', )} d2.enabled = False assert dc.lookup(('TEFT', )) == 'test1' assert dc.raw_lookup(('TEFT', )) == 'test1' assert dc.casereverse_lookup('testing') == ['Testing'] assert dc.reverse_lookup('Testing') == {('TEFGT', )} d1.enabled = False assert dc.lookup(('TEST', )) is None assert dc.raw_lookup(('TEFT', )) is None assert dc.casereverse_lookup('testing') == [] assert dc.reverse_lookup('Testing') == set()
def test_dictionary_collection(self): dc = StenoDictionaryCollection() d1 = StenoDictionary() d1[('S',)] = 'a' d1[('T',)] = 'b' d1.path = 'd1' d2 = StenoDictionary() d2[('S',)] = 'c' d2[('W',)] = 'd' d2.path = 'd2' dc.set_dicts([d2, d1]) self.assertEqual(dc.lookup(('S',)), 'c') self.assertEqual(dc.lookup(('W',)), 'd') self.assertEqual(dc.lookup(('T',)), 'b') f = lambda k, v: v == 'c' dc.add_filter(f) self.assertIsNone(dc.lookup(('S',))) self.assertEqual(dc.raw_lookup(('S',)), 'c') self.assertEqual(dc.lookup(('W',)), 'd') self.assertEqual(dc.lookup(('T',)), 'b') self.assertEqual(dc.reverse_lookup('c'), [('S',)]) dc.remove_filter(f) self.assertEqual(dc.lookup(('S',)), 'c') self.assertEqual(dc.lookup(('W',)), 'd') self.assertEqual(dc.lookup(('T',)), 'b') self.assertEqual(dc.reverse_lookup('c'), [('S',)]) dc.set(('S',), 'e') self.assertEqual(dc.lookup(('S',)), 'e') self.assertEqual(d2[('S',)], 'e') dc.set(('S',), 'f', path='d1') self.assertEqual(dc.lookup(('S',)), 'e') self.assertEqual(d1[('S',)], 'f') self.assertEqual(d2[('S',)], 'e') # Iterating on a StenoDictionaryCollection is # the same as iterating on its dictionaries' paths. self.assertEqual(list(dc), ['d2', 'd1']) # Test get and []. self.assertEqual(dc.get('d1'), d1) self.assertEqual(dc['d1'], d1) self.assertEqual(dc.get('invalid'), None) with self.assertRaises(KeyError): dc['invalid']
def setup_method(self): self.t = Translator() self.s = type(self).FakeState() self.t._state = self.s self.d = StenoDictionary() self.dc = StenoDictionaryCollection([self.d]) self.t.set_dictionary(self.dc)
def test_dictionary_collection(): d1 = StenoDictionary() d1[('S',)] = 'a' d1[('T',)] = 'b' d1.path = 'd1' d2 = StenoDictionary() d2[('S',)] = 'c' d2[('W',)] = 'd' d2.path = 'd2' dc = StenoDictionaryCollection([d2, d1]) assert dc.lookup(('S',)) == 'c' assert dc.lookup(('W',)) == 'd' assert dc.lookup(('T',)) == 'b' f = lambda k, v: v == 'c' dc.add_filter(f) assert dc.lookup(('S',)) is None assert dc.raw_lookup(('S',)) == 'c' assert dc.lookup(('W',)) == 'd' assert dc.lookup(('T',)) == 'b' assert dc.reverse_lookup('c') == [('S',)] dc.remove_filter(f) assert dc.lookup(('S',)) == 'c' assert dc.lookup(('W',)) == 'd' assert dc.lookup(('T',)) == 'b' assert dc.reverse_lookup('c') == [('S',)] dc.set(('S',), 'e') assert dc.lookup(('S',)) == 'e' assert d2[('S',)] == 'e' dc.set(('S',), 'f', path='d1') assert dc.lookup(('S',)) == 'e' assert d1[('S',)] == 'f' assert d2[('S',)] == 'e' # Iterating on a StenoDictionaryCollection is # the same as iterating on its dictionaries' paths. assert list(dc) == ['d2', 'd1'] # Test get and []. assert dc.get('d1') == d1 assert dc['d1'] == d1 assert dc.get('invalid') is None with pytest.raises(KeyError): dc['invalid']
def test_reverse_lookup(): dc = StenoDictionaryCollection() d1 = StenoDictionary() d1[('PWAOUFL', )] = 'beautiful' d1[('WAOUFL', )] = 'beautiful' d2 = StenoDictionary() d2[('PW-FL', )] = 'beautiful' d3 = StenoDictionary() d3[('WAOUFL', )] = 'not beautiful' # Simple test. dc.set_dicts([d1]) assert dc.reverse_lookup('beautiful') == {('PWAOUFL', ), ('WAOUFL', )} # No duplicates. d2_copy = StenoDictionary() d2_copy.update(d2) dc.set_dicts([d2_copy, d2]) assert dc.reverse_lookup('beautiful') == {('PW-FL', )} # Don't stop at the first dictionary with matches. dc.set_dicts([d2, d1]) assert dc.reverse_lookup('beautiful') == {('PW-FL', ), ('PWAOUFL', ), ('WAOUFL', )} # Ignore keys overridden by a higher precedence dictionary. dc.set_dicts([d3, d2, d1]) assert dc.reverse_lookup('beautiful') == {('PW-FL', ), ('PWAOUFL', )}
def test_dictionary_collection_longest_key(self): k1 = ('S', ) k2 = ('S', 'T') k3 = ('S', 'T', 'R') dc = StenoDictionaryCollection() self.assertEqual(dc.longest_key, 0) d1 = StenoDictionary() d1._path = 'd1' d1.save = lambda: None d1[k1] = 'a' dc.set_dicts([d1]) self.assertEqual(dc.longest_key, 1) d1[k2] = 'a' self.assertEqual(dc.longest_key, 2) d2 = StenoDictionary() d2._path = 'd2' d2[k3] = 'c' dc.set_dicts([d1, d2]) self.assertEqual(dc.longest_key, 3) del d1[k2] self.assertEqual(dc.longest_key, 3) dc.set_dicts([d1]) self.assertEqual(dc.longest_key, 1) dc.set_dicts([]) self.assertEqual(dc.longest_key, 0)
def setup_method(self): self.d = StenoDictionary() self.dc = StenoDictionaryCollection([self.d]) self.s = _State() self.o = self.CaptureOutput() self.tlor = Translator() self.tlor.set_dictionary(self.dc) self.tlor.add_listener(self.o) self.tlor.set_state(self.s)
def blackbox_setup(blackbox): blackbox.output = CaptureOutput() blackbox.formatter = Formatter() blackbox.formatter.set_output(blackbox.output) blackbox.translator = Translator() blackbox.translator.set_min_undo_length(100) blackbox.translator.add_listener(blackbox.formatter.format) blackbox.dictionary = blackbox.translator.get_dictionary() blackbox.dictionary.set_dicts([StenoDictionary()])
def test_casereverse_lookup(): dc = StenoDictionaryCollection() d1 = StenoDictionary() d1[('PWAOUFL', )] = 'beautiful' d1[('WAOUFL', )] = 'beAuTIFul' d2 = StenoDictionary() d2[('PW-FL', )] = 'BEAUTIFUL' d3 = StenoDictionary() d3[('WAOUFL', )] = 'not beautiful' dc.set_dicts([d1, d2, d3]) assert dc.casereverse_lookup('beautiful') == { 'beautiful', 'BEAUTIFUL', 'beAuTIFul' }
def setUp(self): self.output = CaptureOutput() self.formatter = Formatter() self.formatter.set_output(self.output) self.translator = Translator() self.translator.set_min_undo_length(100) self.translator.add_listener(self.formatter.format) self.dictionary = self.translator.get_dictionary() self.dictionary.set_dicts([StenoDictionary()])
def load_dictionary(s): """Load an RTF/CRE dictionary.""" styles = load_stylesheet(s) d = {} converter = TranslationConverter(styles) for m in DICT_ENTRY_PATTERN.finditer(s): steno = normalize_steno(m.group('steno')) translation = m.group('translation') converted = converter(translation) if converted is not None: d[steno] = converted return StenoDictionary(d)
def test_dictionary_enabled(): dc = StenoDictionaryCollection() d1 = StenoDictionary() d1.path = 'd1' d1[('TEFT',)] = 'test1' d1[('TEFGT',)] = 'Testing' d2 = StenoDictionary() d2[('TEFT',)] = 'test2' d2[('TEFT', '-G')] = 'Testing' d2.path = 'd2' dc.set_dicts([d2, d1]) assert dc.lookup(('TEFT',)) == 'test2' assert dc.raw_lookup(('TEFT',)) == 'test2' assert dc.casereverse_lookup('testing') == ['Testing'] assert dc.reverse_lookup('Testing') == [('TEFT', '-G'), ('TEFGT',)] d2.enabled = False assert dc.lookup(('TEFT',)) == 'test1' assert dc.raw_lookup(('TEFT',)) == 'test1' assert dc.casereverse_lookup('testing') == ['Testing'] assert dc.reverse_lookup('Testing') == [('TEFGT',)] d1.enabled = False assert dc.lookup(('TEST',)) is None assert dc.raw_lookup(('TEFT',)) is None assert dc.casereverse_lookup('testing') is None assert dc.reverse_lookup('Testing') == []
def test_dictionary_enabled(self): dc = StenoDictionaryCollection() d1 = StenoDictionary() d1.path = 'd1' d1[('TEFT',)] = 'test1' d1[('TEFGT',)] = 'Testing' d2 = StenoDictionary() d2[('TEFT',)] = 'test2' d2[('TEFT','-G')] = 'Testing' d2.path = 'd2' dc.set_dicts([d2, d1]) self.assertEqual(dc.lookup(('TEFT',)), 'test2') self.assertEqual(dc.raw_lookup(('TEFT',)), 'test2') self.assertEqual(dc.casereverse_lookup('testing'), ['Testing']) assertCountEqual(self, dc.reverse_lookup('Testing'), [('TEFGT',), ('TEFT', '-G')]) d2.enabled = False self.assertEqual(dc.lookup(('TEFT',)), 'test1') self.assertEqual(dc.raw_lookup(('TEFT',)), 'test1') self.assertEqual(dc.casereverse_lookup('testing'), ['Testing']) assertCountEqual(self, dc.reverse_lookup('Testing'), [('TEFGT',)]) d1.enabled = False self.assertEqual(dc.lookup(('TEST',)), None) self.assertEqual(dc.raw_lookup(('TEFT',)), None) self.assertEqual(dc.casereverse_lookup('testing'), None) assertCountEqual(self, dc.reverse_lookup('Testing'), [])
def test_dictionary_collection_longest_key(): k1 = ('S', ) k2 = ('S', 'T') k3 = ('S', 'T', 'R') dc = StenoDictionaryCollection() assert dc.longest_key == 0 d1 = StenoDictionary() d1.path = 'd1' d1[k1] = 'a' dc.set_dicts([d1]) assert dc.longest_key == 1 d1[k2] = 'a' assert dc.longest_key == 2 d2 = StenoDictionary() d2.path = 'd2' d2[k3] = 'c' dc.set_dicts([d2, d1]) assert dc.longest_key == 3 del d1[k2] assert dc.longest_key == 3 dc.set_dicts([d1]) assert dc.longest_key == 1 dc.set_dicts([]) assert dc.longest_key == 0
def test_dictionary(self): notifications = [] def listener(longest_key): notifications.append(longest_key) d = StenoDictionary() self.assertEqual(d.longest_key, 0) d.add_longest_key_listener(listener) d[('S', )] = 'a' self.assertEqual(d.longest_key, 1) self.assertEqual(notifications, [1]) d[('S', 'S', 'S', 'S')] = 'b' self.assertEqual(d.longest_key, 4) self.assertEqual(notifications, [1, 4]) d[('S', 'S')] = 'c' self.assertEqual(d.longest_key, 4) self.assertEqual(d[('S', 'S')], 'c') self.assertEqual(notifications, [1, 4]) del d[('S', 'S', 'S', 'S')] self.assertEqual(d.longest_key, 2) self.assertEqual(notifications, [1, 4, 2]) del d[('S', )] self.assertEqual(d.longest_key, 2) self.assertEqual(notifications, [1, 4, 2]) d.clear() self.assertEqual(d.longest_key, 0) self.assertEqual(notifications, [1, 4, 2, 0]) d.remove_longest_key_listener(listener) d[('S', 'S')] = 'c' self.assertEqual(d.longest_key, 2) self.assertEqual(notifications, [1, 4, 2, 0]) self.assertEqual(list(StenoDictionary([('a', 'b')]).items()), [('a', 'b')]) self.assertEqual(list(StenoDictionary(a='b').items()), [('a', 'b')])
def load_dictionary(filename): """Load an RTF/CRE dictionary.""" with resource_stream(filename) as fp: s = fp.read().decode('cp1252') styles = load_stylesheet(s) d = {} converter = TranslationConverter(styles) for m in DICT_ENTRY_PATTERN.finditer(s): steno = normalize_steno(m.group('steno')) translation = m.group('translation') converted = converter(translation) if converted is not None: d[steno] = converted return StenoDictionary(d)
def load_dictionary(filename): for encoding in ('utf-8', 'latin-1'): try: with resource_stream(filename, encoding=encoding) as fp: d = json.load(fp) break except UnicodeDecodeError: continue else: raise ValueError('\'%s\' encoding could not be determined' % (filename, )) return StenoDictionary( (normalize_steno(x[0]), x[1]) for x in iteritems(dict(d)))
def test_changing_state(self): output = [] def listener(undo, do, prev): prev = list(prev) if prev else None output.append((undo, do, prev)) d = StenoDictionary() d[('S', 'P')] = 'hi' dc = StenoDictionaryCollection() dc.set_dicts([d]) t = Translator() t.set_dictionary(dc) t.translate(stroke('T')) t.translate(stroke('S')) s = copy.deepcopy(t.get_state()) t.add_listener(listener) expected = [([Translation([stroke('S')], None)], [Translation([stroke('S'), stroke('P')], 'hi')], [Translation([stroke('T')], None)])] t.translate(stroke('P')) self.assertEqual(output, expected) del output[:] t.set_state(s) t.translate(stroke('P')) self.assertEqual(output, expected) del output[:] t.clear_state() t.translate(stroke('P')) self.assertEqual(output, [([], [Translation([stroke('P')], None)], None)]) del output[:] t.set_state(s) t.translate(stroke('P')) self.assertEqual(output, [([], [Translation([stroke('P')], None)], [Translation([stroke('S'), stroke('P')], 'hi')])])
def test_dictionary_collection(self): dc = StenoDictionaryCollection() d1 = StenoDictionary() d1[('S', )] = 'a' d1[('T', )] = 'b' d1.path = 'd1' d2 = StenoDictionary() d2[('S', )] = 'c' d2[('W', )] = 'd' d2.path = 'd2' dc.set_dicts([d2, d1]) self.assertEqual(dc.lookup(('S', )), 'c') self.assertEqual(dc.lookup(('W', )), 'd') self.assertEqual(dc.lookup(('T', )), 'b') f = lambda k, v: v == 'c' dc.add_filter(f) self.assertIsNone(dc.lookup(('S', ))) self.assertEqual(dc.raw_lookup(('S', )), 'c') self.assertEqual(dc.lookup(('W', )), 'd') self.assertEqual(dc.lookup(('T', )), 'b') self.assertEqual(dc.reverse_lookup('c'), [('S', )]) dc.remove_filter(f) self.assertEqual(dc.lookup(('S', )), 'c') self.assertEqual(dc.lookup(('W', )), 'd') self.assertEqual(dc.lookup(('T', )), 'b') self.assertEqual(dc.reverse_lookup('c'), [('S', )]) dc.set(('S', ), 'e') self.assertEqual(dc.lookup(('S', )), 'e') self.assertEqual(d2[('S', )], 'e') dc.set(('S', ), 'f', path='d1') self.assertEqual(dc.lookup(('S', )), 'e') self.assertEqual(d1[('S', )], 'f') self.assertEqual(d2[('S', )], 'e') # Iterating on a StenoDictionaryCollection is # the same as iterating on its dictionaries' paths. self.assertEqual(list(dc), ['d2', 'd1']) # Test get and []. self.assertEqual(dc.get('d1'), d1) self.assertEqual(dc['d1'], d1) self.assertEqual(dc.get('invalid'), None) with self.assertRaises(KeyError): dc['invalid']
def test_dictionary_collection(): d1 = StenoDictionary() d1[('S', )] = 'a' d1[('T', )] = 'b' d1.path = 'd1' d2 = StenoDictionary() d2[('S', )] = 'c' d2[('W', )] = 'd' d2.path = 'd2' dc = StenoDictionaryCollection([d2, d1]) assert dc.lookup(('S', )) == 'c' assert dc.lookup(('W', )) == 'd' assert dc.lookup(('T', )) == 'b' f = lambda k, v: v == 'c' dc.add_filter(f) assert dc.lookup(('S', )) is None assert dc.raw_lookup(('S', )) == 'c' assert dc.lookup(('W', )) == 'd' assert dc.lookup(('T', )) == 'b' assert dc.reverse_lookup('c') == {('S', )} dc.remove_filter(f) assert dc.lookup(('S', )) == 'c' assert dc.lookup(('W', )) == 'd' assert dc.lookup(('T', )) == 'b' assert dc.reverse_lookup('c') == {('S', )} dc.set(('S', ), 'e') assert dc.lookup(('S', )) == 'e' assert d2[('S', )] == 'e' dc.set(('S', ), 'f', path='d1') assert dc.lookup(('S', )) == 'e' assert d1[('S', )] == 'f' assert d2[('S', )] == 'e' # Iterating on a StenoDictionaryCollection is # the same as iterating on its dictionaries' paths. assert list(dc) == ['d2', 'd1'] # Test get and []. assert dc.get('d1') == d1 assert dc['d1'] == d1 assert dc.get('invalid') is None with pytest.raises(KeyError): dc['invalid']
def steno_dictionaries_from_state(state_str, existing_dictionaries=None): new_dictionaries = [] for enabled, icon, path in parse_state(state_str): if icon == 'loading': continue path = expand_path(path) if existing_dictionaries is None: steno_dict = None else: steno_dict = existing_dictionaries.get(path) if steno_dict is None: if icon == 'error' or path.endswith('.bad'): steno_dict = ErroredDictionary(path, INVALID_EXCEPTION) else: steno_dict = StenoDictionary() steno_dict.path = path steno_dict.readonly = (icon == 'readonly' or path.endswith('.ro') or path.startswith('asset:')) steno_dict.enabled = enabled new_dictionaries.append(steno_dict) return new_dictionaries
def test_dictionary(self): notifications = [] def listener(longest_key): notifications.append(longest_key) d = StenoDictionary() self.assertEqual(d.longest_key, 0) d.add_longest_key_listener(listener) d[('S',)] = 'a' self.assertEqual(d.longest_key, 1) self.assertEqual(notifications, [1]) d[('S', 'S', 'S', 'S')] = 'b' self.assertEqual(d.longest_key, 4) self.assertEqual(notifications, [1, 4]) d[('S', 'S')] = 'c' self.assertEqual(d.longest_key, 4) self.assertEqual(d[('S', 'S')], 'c') self.assertEqual(notifications, [1, 4]) del d[('S', 'S', 'S', 'S')] self.assertEqual(d.longest_key, 2) self.assertEqual(notifications, [1, 4, 2]) del d[('S',)] self.assertEqual(d.longest_key, 2) self.assertEqual(notifications, [1, 4, 2]) d.clear() self.assertEqual(d.longest_key, 0) self.assertEqual(notifications, [1, 4, 2, 0]) d.remove_longest_key_listener(listener) d[('S', 'S')] = 'c' self.assertEqual(d.longest_key, 2) self.assertEqual(notifications, [1, 4, 2, 0]) self.assertEqual(StenoDictionary([('a', 'b')]).items(), [('a', 'b')]) self.assertEqual(StenoDictionary(a='b').items(), [('a', 'b')])
def test_dictionary_collection(self): dc = StenoDictionaryCollection() d1 = StenoDictionary() d1[('S',)] = 'a' d1[('T',)] = 'b' d1.set_path('d1') d2 = StenoDictionary() d2[('S',)] = 'c' d2[('W',)] = 'd' d2.set_path('d2') dc.set_dicts([d1, d2]) self.assertEqual(dc.lookup(('S',)), 'c') self.assertEqual(dc.lookup(('W',)), 'd') self.assertEqual(dc.lookup(('T',)), 'b') f = lambda k, v: v == 'c' dc.add_filter(f) self.assertIsNone(dc.lookup(('S',))) self.assertEqual(dc.raw_lookup(('S',)), 'c') self.assertEqual(dc.lookup(('W',)), 'd') self.assertEqual(dc.lookup(('T',)), 'b') self.assertEqual(dc.reverse_lookup('c'), [('S',)]) dc.remove_filter(f) self.assertEqual(dc.lookup(('S',)), 'c') self.assertEqual(dc.lookup(('W',)), 'd') self.assertEqual(dc.lookup(('T',)), 'b') self.assertEqual(dc.reverse_lookup('c'), [('S',)]) dc.set(('S',), 'e') self.assertEqual(dc.lookup(('S',)), 'e') self.assertEqual(d2[('S',)], 'e') dc.set(('S',), 'f', dictionary='d1') self.assertEqual(dc.lookup(('S',)), 'e') self.assertEqual(d1[('S',)], 'f') self.assertEqual(d2[('S',)], 'e')
def test_translator(): # It's not clear that this test is needed anymore. There are separate # tests for _translate_stroke and test_translate_calls_translate_stroke # makes sure that translate calls it properly. But since I already wrote # this test I'm going to keep it. class Output: def __init__(self): self._output = [] def write(self, undo, do, prev): for t in undo: self._output.pop() for t in do: if t.english: self._output.append(t.english) else: self._output.append('/'.join(t.rtfcre)) def get(self): return ' '.join(self._output) def clear(self): del self._output[:] d = StenoDictionary() out = Output() t = Translator() dc = StenoDictionaryCollection([d]) t.set_dictionary(dc) t.add_listener(out.write) t.translate(stroke('S')) assert out.get() == 'S' t.translate(stroke('T')) assert out.get() == 'S T' t.translate(stroke('*')) assert out.get() == 'S' t.translate(stroke('*')) # Undo buffer ran out assert out.get() == 'S ' + BACK_STRING t.set_min_undo_length(3) out.clear() t.translate(stroke('S')) assert out.get() == 'S' t.translate(stroke('T')) assert out.get() == 'S T' t.translate(stroke('*')) assert out.get() == 'S' t.translate(stroke('*')) assert out.get() == '' out.clear() d[('S',)] = 't1' d[('T',)] = 't2' d[('S', 'T')] = 't3' t.translate(stroke('S')) assert out.get() == 't1' t.translate(stroke('T')) assert out.get() == 't3' t.translate(stroke('T')) assert out.get() == 't3 t2' t.translate(stroke('S')) assert out.get() == 't3 t2 t1' t.translate(stroke('*')) assert out.get() == 't3 t2' t.translate(stroke('*')) assert out.get() == 't3' t.translate(stroke('*')) assert out.get() == 't1' t.translate(stroke('*')) assert out.get() == '' t.translate(stroke('S')) assert out.get() == 't1' t.translate(stroke('T')) assert out.get() == 't3' t.translate(stroke('T')) assert out.get() == 't3 t2' d[('S', 'T', 'T')] = 't4' d[('S', 'T', 'T', 'S')] = 't5' t.translate(stroke('S')) assert out.get() == 't5' t.translate(stroke('*')) assert out.get() == 't3 t2' t.translate(stroke('*')) assert out.get() == 't3' t.translate(stroke('T')) assert out.get() == 't4' t.translate(stroke('S')) assert out.get() == 't5' t.translate(stroke('S')) assert out.get() == 't5 t1' t.translate(stroke('*')) assert out.get() == 't5' t.translate(stroke('*')) assert out.get() == 't4' t.translate(stroke('*')) assert out.get() == 't3' t.translate(stroke('*')) assert out.get() == 't1' t.translate(stroke('*')) assert out.get() == '' d.clear() s = stroke('S') t.translate(s) t.translate(s) t.translate(s) t.translate(s) s = stroke('*') t.translate(s) t.translate(s) t.translate(s) t.translate(s) # Not enough undo to clear output. assert out.get() == 'S ' + BACK_STRING out.clear() t.remove_listener(out.write) t.translate(stroke('S')) assert out.get() == ''
def test_dictionary(): notifications = [] def listener(longest_key): notifications.append(longest_key) d = StenoDictionary() assert d.longest_key == 0 d.add_longest_key_listener(listener) d[('S',)] = 'a' assert d.longest_key == 1 assert notifications == [1] d[('S', 'S', 'S', 'S')] = 'b' assert d.longest_key == 4 assert notifications == [1, 4] d[('S', 'S')] = 'c' assert d.longest_key == 4 assert d[('S', 'S')] == 'c' assert notifications == [1, 4] del d[('S', 'S', 'S', 'S')] assert d.longest_key == 2 assert notifications == [1, 4, 2] del d[('S',)] assert d.longest_key == 2 assert notifications == [1, 4, 2] assert d.reverse_lookup('c') == [('S', 'S')] assert d.casereverse_lookup('c') == ['c'] d.clear() assert d.longest_key == 0 assert notifications == [1, 4, 2, 0] assert d.reverse_lookup('c') == [] assert d.casereverse_lookup('c') == [] d.remove_longest_key_listener(listener) d[('S', 'S')] = 'c' assert d.longest_key == 2 assert notifications == [1, 4, 2, 0]
# Deleting the file will fail on Windows # if we don't restore write permission. os.chmod(tf.name, stat.S_IWRITE) os.unlink(tf.name) # Assets are always readonly. d = FakeDictionary.load('asset:plover:assets/main.json') assert d.readonly TEST_DICTIONARY_UPDATE_DICT = { ('S-G',): 'something', ('SPH-G',): 'something', ('SPH*G',): 'Something', ('SPH', 'THEUPBG'): 'something', } TEST_DICTIONARY_UPDATE_STENODICT = StenoDictionary() TEST_DICTIONARY_UPDATE_STENODICT.update(TEST_DICTIONARY_UPDATE_DICT) @pytest.mark.parametrize('update_from, start_empty', ( (dict(TEST_DICTIONARY_UPDATE_DICT), True), (dict(TEST_DICTIONARY_UPDATE_DICT), False), (list(TEST_DICTIONARY_UPDATE_DICT.items()), True), (list(TEST_DICTIONARY_UPDATE_DICT.items()), False), (iter(TEST_DICTIONARY_UPDATE_DICT.items()), True), (iter(TEST_DICTIONARY_UPDATE_DICT.items()), False), (TEST_DICTIONARY_UPDATE_STENODICT, True), (TEST_DICTIONARY_UPDATE_STENODICT, False), )) def test_dictionary_update(update_from, start_empty): d = StenoDictionary() if not start_empty:
def test_translator(): # It's not clear that this test is needed anymore. There are separate # tests for _translate_stroke and test_translate_calls_translate_stroke # makes sure that translate calls it properly. But since I already wrote # this test I'm going to keep it. class Output: def __init__(self): self._output = [] def write(self, undo, do, prev): for t in undo: self._output.pop() for t in do: if t.english: self._output.append(t.english) else: self._output.append('/'.join(t.rtfcre)) def get(self): return ' '.join(self._output) def clear(self): del self._output[:] d = StenoDictionary() out = Output() t = Translator() dc = StenoDictionaryCollection([d]) t.set_dictionary(dc) t.add_listener(out.write) t.translate(stroke('S')) assert out.get() == 'S' t.translate(stroke('T')) assert out.get() == 'S T' t.translate(stroke('*')) assert out.get() == 'S' t.translate(stroke('*')) # Undo buffer ran out assert out.get() == 'S ' + BACK_STRING t.set_min_undo_length(3) out.clear() t.translate(stroke('S')) assert out.get() == 'S' t.translate(stroke('T')) assert out.get() == 'S T' t.translate(stroke('*')) assert out.get() == 'S' t.translate(stroke('*')) assert out.get() == '' out.clear() d[('S', )] = 't1' d[('T', )] = 't2' d[('S', 'T')] = 't3' t.translate(stroke('S')) assert out.get() == 't1' t.translate(stroke('T')) assert out.get() == 't3' t.translate(stroke('T')) assert out.get() == 't3 t2' t.translate(stroke('S')) assert out.get() == 't3 t2 t1' t.translate(stroke('*')) assert out.get() == 't3 t2' t.translate(stroke('*')) assert out.get() == 't3' t.translate(stroke('*')) assert out.get() == 't1' t.translate(stroke('*')) assert out.get() == '' t.translate(stroke('S')) assert out.get() == 't1' t.translate(stroke('T')) assert out.get() == 't3' t.translate(stroke('T')) assert out.get() == 't3 t2' d[('S', 'T', 'T')] = 't4' d[('S', 'T', 'T', 'S')] = 't5' t.translate(stroke('S')) assert out.get() == 't5' t.translate(stroke('*')) assert out.get() == 't3 t2' t.translate(stroke('*')) assert out.get() == 't3' t.translate(stroke('T')) assert out.get() == 't4' t.translate(stroke('S')) assert out.get() == 't5' t.translate(stroke('S')) assert out.get() == 't5 t1' t.translate(stroke('*')) assert out.get() == 't5' t.translate(stroke('*')) assert out.get() == 't4' t.translate(stroke('*')) assert out.get() == 't3' t.translate(stroke('*')) assert out.get() == 't1' t.translate(stroke('*')) assert out.get() == '' d.clear() s = stroke('S') t.translate(s) t.translate(s) t.translate(s) t.translate(s) s = stroke('*') t.translate(s) t.translate(s) t.translate(s) t.translate(s) # Not enough undo to clear output. assert out.get() == 'S ' + BACK_STRING out.clear() t.remove_listener(out.write) t.translate(stroke('S')) assert out.get() == ''
def test_dictionary_update(update_from, start_empty): d = StenoDictionary() if not start_empty: d.update({ ('SPH*G',): 'not something', ('STHEUPBG',): 'something', ('EF', 'REU', 'TH*EUPBG'): 'everything', }) assert d[('STHEUPBG',)] == 'something' assert d[('EF', 'REU', 'TH*EUPBG')] == 'everything' assert d.reverse_lookup('not something') == [('SPH*G',)] assert d.longest_key == 3 d.update(update_from) assert d[('S-G',)] == 'something' assert d[('SPH-G',)] == 'something' assert d[('SPH*G',)] == 'Something' assert d[('SPH', 'THEUPBG')] == 'something' if not start_empty: assert d[('STHEUPBG',)] == 'something' assert d[('EF', 'REU', 'TH*EUPBG')] == 'everything' assert d.reverse_lookup('not something') == [] assert sorted(d.reverse_lookup('something')) == sorted([('STHEUPBG',), ('S-G',), ('SPH-G',), ('SPH', 'THEUPBG')]) assert sorted(d.casereverse_lookup('something')) == sorted(['something', 'Something']) assert d.longest_key == 3 else: assert sorted(d.reverse_lookup('something')) == sorted([('S-G',), ('SPH-G',), ('SPH', 'THEUPBG')]) assert sorted(d.casereverse_lookup('something')) == sorted(['something', 'Something']) assert d.longest_key == 2
def test_search(): dc = StenoDictionaryCollection() # Similarity is based on string equality after removing case and stripping special characters from the ends. d1 = StenoDictionary() d1[('WAOUFL', )] = 'beautiful' d1[('PWAOUFL', )] = 'Beautiful' d1[('PWAOUT', '-FL')] = '{^BEAUTIFUL} ' d1[('ULG', )] = 'ugly' dc.set_dicts([d1]) assert dc.find_similar('beautiful') == [('Beautiful', {('PWAOUFL', )}), ('beautiful', {('WAOUFL', )}), ('{^BEAUTIFUL} ', {('PWAOUT', '-FL')})] assert dc.find_similar('{#BEAUtiful}{^}') == [ ('Beautiful', {('PWAOUFL', )}), ('beautiful', {('WAOUFL', )}), ('{^BEAUTIFUL} ', {('PWAOUT', '-FL')}) ] # Translations found in multiple dicts should combine non-overlapping keys in the results. d2 = StenoDictionary() del d1[('PWAOUT', '-FL')] d2[('PW-FL', )] = 'beautiful' dc.set_dicts([d1, d2]) assert dc.find_similar('beautiful') == [('Beautiful', {('PWAOUFL', )}), ('beautiful', {('WAOUFL', ), ('PW-FL', )})] # If all possible keys for a translation are overridden, that translation should not be returned. d3 = StenoDictionary() d3[('PW-FL', )] = 'not beautiful' d3[('WAOUFL', )] = 'not beautiful' dc.set_dicts([d3, d1, d2]) assert dc.find_similar('beautiful') == [('Beautiful', {('PWAOUFL', )})] # For partial word search, similar words will be returned first, but if the count is greater than that, # the next words in sorted order which are supersets are returned. Also stops at the end of the dictionary. dc.set_dicts([d1]) d1[('PWAOU', )] = 'beau' d1[('PWAOUFL', 'HREU')] = 'beautifully' d1[('UG', 'HREU', '-PBS')] = 'ugliness' assert dc.find_partial('beau', count=4) == [('beau', {('PWAOU', )}), ('Beautiful', {('PWAOUFL', )}), ('beautiful', {('WAOUFL', )}), ('beautifully', {('PWAOUFL', 'HREU')})] assert dc.find_partial('UGLY', count=2) == [('ugly', {('ULG', )})] # Even if a word isn't present, the search will return words going forward # from the index where it would be found if it was there. assert dc.find_partial('beaut', count=3) == [('Beautiful', {('PWAOUFL', )}), ('beautiful', {('WAOUFL', )}), ('beautifully', {('PWAOUFL', 'HREU')})] # Regex search is straightforward; return up to count entries in order that match the given regular expression. # If no regex metacharacters are present, should just be a case-sensitive starts-with search. assert dc.find_regex('beau', count=4) == [('beau', {('PWAOU', )}), ('beautiful', {('WAOUFL', )}), ('beautifully', {('PWAOUFL', 'HREU')})] assert dc.find_regex('beautiful.?.?', count=2) == [('beautiful', {('WAOUFL', )}), ('beautifully', {('PWAOUFL', 'HREU')})] assert dc.find_regex(' beautiful', count=3) == [] assert dc.find_regex('(b|u).{3}$', count=2) == [('beau', {('PWAOU', )}), ('ugly', {('ULG', )})] assert dc.find_regex('.*ly', count=5) == [('beautifully', {('PWAOUFL', 'HREU')}), ('ugly', {('ULG', )})] # Regex errors won't raise if the algorithm short circuits a pattern with no possible matches. assert dc.find_regex('an open group that doesn\'t raise(', count=5) == [] with pytest.raises(re.error): print(dc.find_regex('beautiful...an open group(', count=1))
def test_dictionary_update(update_from, start_empty): d = StenoDictionary() if not start_empty: d.update({ ('SPH*G', ): 'not something', ('STHEUPBG', ): 'something', ('EF', 'REU', 'TH*EUPBG'): 'everything', }) assert d[('STHEUPBG', )] == 'something' assert d[('EF', 'REU', 'TH*EUPBG')] == 'everything' assert d.reverse_lookup('not something') == [('SPH*G', )] assert d.longest_key == 3 d.update(update_from) assert d[('S-G', )] == 'something' assert d[('SPH-G', )] == 'something' assert d[('SPH*G', )] == 'Something' assert d[('SPH', 'THEUPBG')] == 'something' if not start_empty: assert d[('STHEUPBG', )] == 'something' assert d[('EF', 'REU', 'TH*EUPBG')] == 'everything' assert d.reverse_lookup('not something') == [] assert d.reverse_lookup('something') == [('STHEUPBG', ), ('S-G', ), ('SPH-G', ), ('SPH', 'THEUPBG')] assert set( d.casereverse_lookup('something')) == {'something', 'Something'} assert d.longest_key == 3 else: assert d.reverse_lookup('something') == [('S-G', ), ('SPH-G', ), ('SPH', 'THEUPBG')] assert set( d.casereverse_lookup('something')) == {'something', 'Something'} assert d.longest_key == 2
def test_dictionary_update(): d = StenoDictionary() d.update([(('S-G', ), 'something'), (('SPH-G', ), 'something'), (('TPHOG', ), 'nothing')]) assert d[('S-G', )] == 'something' assert d[('SPH-G', )] == 'something' assert d[('TPHOG', )] == 'nothing' assert d.reverse_lookup('something') == [('S-G', ), ('SPH-G', )] assert d.reverse_lookup('nothing') == [('TPHOG', )] d.update([(('S-G', ), 'string')]) assert d[('S-G', )] == 'string' assert d.reverse_lookup('something') == [('SPH-G', )] assert d.reverse_lookup('string') == [('S-G', )] d.clear() d.update([(('EFG', ), 'everything'), (('EFG', ), 'everything???')]) assert d[('EFG', )] == 'everything???' assert d.reverse_lookup('everything') == [] assert d.reverse_lookup('everything???') == [('EFG', )]