def alphabet_contains(alphabet, symbol):
try:
ind = alphabet.index(symbol)
except ValueError:
return False
return True
print("HfstBasicTransducer construction")
# Create an HfstBasicTransducer [a:b c:d] with weight 3.0
t = libhfst.HfstBasicTransducer()
assert (not t.is_final_state(0))
s1 = t.add_state()
assert (s1 == 1)
t.add_transition(0, libhfst.HfstBasicTransition(s1, "a", "b", 1.2))
assert (not t.is_final_state(s1))
s2 = t.add_state()
assert (s2 == 2)
t.add_transition(s1, libhfst.HfstBasicTransition(s2, "c", "d", 0.8))
assert (not t.is_final_state(s2))
t.set_final_weight(s2, 1.0)
assert (t.is_final_state(s2) and t.get_final_weight(s2) == 1.0)
# Take a copy
tc = libhfst.HfstBasicTransducer(t)
print("HfstBasicTransducer exceptions")
# Asking the weight of a non-final state
for s in range(5):
tok.add_multichar_symbol('foo')
tok.add_multichar_symbol('bar')
tr = libhfst.tokenized_fst(tok.tokenize('foobar', 'foobaz'))
if not tr.compare(libhfst.regex('[foo:foo bar:b 0:a 0:z]')):
raise RuntimeError('')
# HfstBasicTransducer
# Create an empty transducer
# The transducer has initially one start state (number zero)
# that is not final
fsm = libhfst.HfstBasicTransducer()
# Add two states to the transducer
fsm.add_state(1)
fsm.add_state(2)
# Create a transition [foo:bar] leading to state 1 with weight 0.1
tr = libhfst.HfstBasicTransition(1, 'foo', 'bar', 0.1)
# and add it to state zero
fsm.add_transition(0, tr)
# Add a transition [baz:baz] with weight 0 from state 1 to state 2
fsm.add_transition(1, libhfst.HfstBasicTransition(2, 'baz', 'baz', 0.0))
# Set state 2 as final with weight 0.3
fsm.set_final_weight(2, 0.3)
# Go through all states
for state, arcs in enumerate(fsm):
for arc in arcs:
print('%i ' % (state), end='')
print(arc)
if fsm.is_final_state(state):
print('%i %f' % (state, fsm.get_final_weight(state)))
for state in fsm.states():
## @package libhfst
# Documentation for libhfst
# HfstBasicTransducer
# -------------------
print("HfstBasicTransducer")
# Create an empty transducer
# The transducer has initially one start state (number zero)
# that is not final
fsm = libhfst.HfstBasicTransducer()
# Add two states to the transducer
fsm.add_state(1)
fsm.add_state(2)
# Create a transition [foo:bar] leading to state 1 with weight 0.1
tr = libhfst.HfstBasicTransition(1, 'foo', 'bar', 0.1)
# and add it to state zero
fsm.add_transition(0, tr)
# Add a transition [baz:baz] with weight 0 from state 1 to state 2
fsm.add_transition(1, libhfst.HfstBasicTransition(2, 'baz', 'baz', 0.0))
# Set state 2 as final with weight 0.3
fsm.set_final_weight(2, 0.3)
# Go through all states
for state in fsm.states():
# Go through all transitions
for transition in fsm.transitions(state):
print("{0} {1} {2} {3} {4}".format(state,
transition.get_target_state(),
transition.get_input_symbol(),
transition.get_output_symbol(),
import libhfst
t = libhfst.HfstBasicTransducer()
s1 = t.add_state()
s2 = t.add_state()
s3 = t.add_state()
s4 = t.add_state()
s5 = t.add_state()
s6 = t.add_state()
t.set_final_weight(s6, 0)
fd1 = "@U.FEATURE.FOO@"
fd2 = "@U.FEATURE.BAR@"
t.add_transition(0, libhfst.HfstBasicTransition(s1, fd1, fd1, 0))
t.add_transition(0, libhfst.HfstBasicTransition(s2, "a", "a", 0))
t.add_transition(s1, libhfst.HfstBasicTransition(s3, "b", "b", 0))
t.add_transition(s2, libhfst.HfstBasicTransition(s3, fd2, fd2, 0))
t.add_transition(s3, libhfst.HfstBasicTransition(s4, "c", "c", 0))
t.add_transition(s3, libhfst.HfstBasicTransition(s5, "d", "d", 0))
t.add_transition(s4, libhfst.HfstBasicTransition(s6, fd2, fd2, 0))
t.add_transition(s5, libhfst.HfstBasicTransition(s6, fd1, fd1, 0))
types = [libhfst.SFST_TYPE, libhfst.TROPICAL_OPENFST_TYPE, libhfst.FOMA_TYPE]
for type in types:
if not libhfst.HfstTransducer.is_implementation_type_available(type):
continue
print("Identitites with flags")
tr = libhfst.regex('foo\\', error=msg)
# lexc compiler
msg = io.StringIO()
tr = libhfst.compile_lexc_file('test.lexc', output=msg, verbosity=2)
print('This is the output from lexc:')
print(msg.getvalue())
print('\n--- Testing HfstBasicTransducer ---\n')
# Create basic transducer, write it to file, read it, and test equivalence
fsm = libhfst.HfstBasicTransducer()
fsm.add_state(0)
fsm.add_state(1)
fsm.set_final_weight(1, 0.3)
tr = libhfst.HfstBasicTransition(1, 'foo', 'bar', 0.5)
fsm.add_transition(0, tr)
fsm.add_transition(0, 0, 'baz', 'baz')
fsm.add_transition(0, 0, 'baz', 'BAZ', 0.1)
f = libhfst.hfst_open('foo_basic', 'w')
fsm.write_att(f)
f.close()
f = libhfst.hfst_open('foo_basic', 'r')
fsm2 = libhfst.HfstBasicTransducer.read_att(f, libhfst.EPSILON)
f.close()
FSM = libhfst.HfstTransducer(fsm, libhfst.FOMA_TYPE)
FSM2 = libhfst.HfstTransducer(fsm2, libhfst.FOMA_TYPE)
# One-transition transducer
print("One-transition transducer")
foo = libhfst.HfstTransducer("foo", type)
foobar = libhfst.HfstTransducer("foo", "bar", type)
# The copy constructor
print("The copy constructor")
foobar_copy = libhfst.HfstTransducer(foobar)
assert (foobar.compare(foobar_copy))
# Conversion from HfstBasicTransducer
print("Conversion from HfstBasicTransducer")
basic = libhfst.HfstBasicTransducer()
basic.add_state(1)
basic.add_transition(0, libhfst.HfstBasicTransition(1, "foo", "bar", 0))
basic.set_final_weight(1, 0)
foobar_basic = libhfst.HfstTransducer(basic, type)
assert (foobar.compare(foobar_basic))
# By tokenizing
print("Construction by tokenization")
tok = libhfst.HfstTokenizer()
tok.add_skip_symbol("baz")
tok.add_multichar_symbol("foo")
tok.add_multichar_symbol("bar")
foo_tok = libhfst.HfstTransducer("bazfoobaz", tok, type)
foobar_tok = libhfst.HfstTransducer("bazfoo", "barbaz", tok, type)
assert (foo.compare(foo_tok))
assert (foobar.compare(foobar_tok))