HFST - Helsinki Finite-State Transducer Technology - Python API  version 3.10.0
 All Classes Namespaces Files Functions Variables Pages
Public Member Functions | List of all members
HfstTransducer Class Reference

A synchronous finite-state transducer. More...

Public Member Functions

def __init__
 Create an empty transducer. More...
 
def __init__
 Create a deep copy of HfstTransducer another or a transducer equivalent to HfstBasicTransducer another. More...
 
def __init__
 Create an HFST transducer equivalent to HfstBasicTransducer t. More...
 
def __str__
 An AT&T representation of the transducer. More...
 
def compare
 Whether this transducer and another are equivalent. More...
 
def compose
 Compose this transducer with another. More...
 
def compose_intersect
 Compose this transducer with the intersection of transducers in v. More...
 
def concatenate
 Concatenate this transducer with another. More...
 
def conjunct
 Alias for intersect. More...
 
def convert
 Convert the transducer into an equivalent transducer in format type. More...
 
def copy
 Return a deep copy of the transducer. More...
 
def cross_product
 Make cross product of this transducer with another. More...
 
def determinize
 Determinize the transducer. More...
 
def disjunct
 Disjunct this transducer with another. More...
 
def eliminate_flag
 Eliminate flag diacritic symbol from the transducer. More...
 
def eliminate_flags
 Eliminate flag diacritics listed in symbols from the transducer. More...
 
def extract_longest_paths
 Extract longest paths of the transducer. More...
 
def extract_paths
 Extract paths that are recognized by the transducer. More...
 
def extract_shortest_paths
 Extract shortest paths of the transducer. More...
 
def get_alphabet
 Get the alphabet of the transducer. More...
 
def get_name
 Get the name of the transducer. More...
 
def get_properties
 Get all properties from the transducer. More...
 
def get_property
 Get arbitrary string propert property. More...
 
def get_type
 The implementation type of the transducer. More...
 
def has_flag_diacritics
 Whether the transducer has flag diacritics in its transitions. More...
 
def input_project
 Extract the input language of the transducer. More...
 
def insert_freely
 Freely insert a transition or a transducer into the transducer. More...
 
def insert_to_alphabet
 Explicitly insert symbol to the alphabet of the transducer. More...
 
def intersect
 Intersect this transducer with another. More...
 
def invert
 Swap the input and output symbols of each transition in the transducer. More...
 
def is_automaton
 Whether each transition in the transducer has equivalent input and output symbols. More...
 
def is_cyclic
 Whether the transducer is cyclic. More...
 
def is_implementation_type_available
 Whether HFST is linked to the transducer library needed by implementation type type. More...
 
def is_infinitely_ambiguous
 Whether the transducer is infinitely ambiguous. More...
 
def is_lookup_infinitely_ambiguous
 Whether lookup of path input will have infinite results. More...
 
def lenient_composition
 Perform a lenient composition on this transducer and another. More...
 
def longest_path_size
 Get length of longest path of the transducer. More...
 
def lookup
 Lookup string input. More...
 
def lookup_optimize
 Optimize the transducer for lookup. More...
 
def minimize
 Minimize the transducer. More...
 
def minus
 Alias for subtract. More...
 
def n_best
 Extract n best paths of the transducer. More...
 
def number_of_arcs
 The number of transitions in the transducer. More...
 
def number_of_states
 The number of states in the transducer. More...
 
def optionalize
 Disjunct the transducer with an epsilon transducer. More...
 
def output_project
 Extract the output language of the transducer. More...
 
def priority_union
 Make priority union of this transducer with another. More...
 
def prune
 Make transducer coaccessible. More...
 
def push_weights_to_end
 Push weights towards final state(s). More...
 
def push_weights_to_start
 Push weights towards initial state. More...
 
def remove_epsilons
 Remove all epsilon:epsilon transitions from the transducer so that the resulting transducer is equivalent to the original one. More...
 
def remove_from_alphabet
 Remove symbol from the alphabet of the transducer. More...
 
def remove_optimization
 Remove lookup optimization. More...
 
def repeat_n
 A concatenation of n transducers. More...
 
def repeat_n_minus
 A concatenation of N transducers where N is any number from zero to n, inclusive. More...
 
def repeat_n_plus
 A concatenation of N transducers where N is any number from n to infinity, inclusive. More...
 
def repeat_n_to_k
 A concatenation of N transducers where N is any number from n to k, inclusive. More...
 
def repeat_plus
 A concatenation of N transducers where N is any number from one to infinity. More...
 
def repeat_star
 A concatenation of N transducers where N is any number from zero to infinity. More...
 
def reverse
 Reverse the transducer. More...
 
def set_final_weights
 Set the weights of all final states to weight. More...
 
def set_name
 Rename the transducer name. More...
 
def set_property
 Set arbitrary string property property to value. More...
 
def shuffle
 Shuffle this transducer with transducer another. More...
 
def substitute
 Substitute symbols or transitions in the transducer. More...
 
def subtract
 Subtract transducer another from this transducer. More...
 
def write
 Write the transducer in binary format to ostr. More...
 
def write_att
 Write the transducer in AT&T format to file f, write_weights defined whether weights are written. More...
 
def write_att
 Write the transducer in AT&T format to file ofile, write_weights defines whether weights are written. More...
 
def write_att
 Write the transducer in AT&T format to file named filename. More...
 
def write_prolog
 Write the transducer in prolog format with name name to file f, write_weights defined whether weights are written. More...
 

Detailed Description

A synchronous finite-state transducer.

Argument handling

Transducer functions modify their calling object and return a reference to the calling object after modification, unless otherwise mentioned. Transducer arguments are usually not modified.

 # transducer is reversed
 transducer.reverse()
 # transducer2 is not modified, but a copy of it is disjuncted with
 # transducer1 
 transducer1.disjunct(transducer2)                                       
 # a chain of functions is possible
 transducer.reverse().determinize().reverse().determinize()      

Implementation types

Currently, an HfstTransducer has three implementation types that are well supported. When an HfstTransducer is created, its type is defined with an argument. For functions that take a transducer as an argument, the type of the calling transducer must be the same as the type of the argument transducer:

 # this will cause a TransducerTypeMismatchException:
 tropical_transducer.disjunct(foma_transducer)
 # this works, but weights are lost in the conversion
 tropical_transducer.convert(hfst.types.SFST_TYPE).disjunct(sfst_transducer)     
 # this works, information is not lost
 tropical_transducer.disjunct(sfst_transducer.convert(hfst.types.TROPICAL_OPENFST_TYPE)) 

Creating transducers

With HfstTransducer constructors it is possible to create empty, epsilon, one-transition and single-path transducers. Transducers can also be created from scratch with hfst.HfstBasicTransducer and converted to an HfstTransducer. More complex transducers can be combined from simple ones with various functions.

Constructor & Destructor Documentation

def __init__ (   self)

Create an empty transducer.

 tr = hfst.HfstTransducer()
 assert(tr.compare(hfst.empty_fst()))
def __init__ (   self,
  another 
)

Create a deep copy of HfstTransducer another or a transducer equivalent to HfstBasicTransducer another.

Parameters
anotherAn HfstTransducer or HfstBasicTransducer.

An example:

 tr1 = hfst.regex('foo bar foo')
 tr2 = hfst.HfstTransducer(tr1)
 tr2.substitute('foo','FOO')
 tr1.concatenate(tr2)
def __init__ (   self,
  t,
  type 
)

Create an HFST transducer equivalent to HfstBasicTransducer t.

The type of the created transducer is defined by type.

Parameters
tAn HfstBasicTransducer.
typeThe type of the resulting transducer. If you want to use the default type, you can just call hfst.HfstTransducer(fsm)

Member Function Documentation

def __str__ (   self)

An AT&T representation of the transducer.

Defined for print command. An example:

 >>> print(hfst.regex('[foo:bar::2]+'))
 0       1       foo     bar     2.000000
 1       1       foo     bar     2.000000
 1       0.000000
Todo:
Works only for small transducers.
def compare (   self,
  another 
)

Whether this transducer and another are equivalent.

Parameters
anotherThe compared transducer.
Precondition
self and another must have the same implementation type.

Two transducers are equivalent iff they accept the same input/output string pairs with the same weights and the same alignments.

Note
For weighted transducers, the function often returns false negatives due to weight precision issues.
def compose (   self,
  another 
)

Compose this transducer with another.

Parameters
anotherThe second argument in the composition. Not modified.
def compose_intersect (   self,
  v,
  invert = False 
)

Compose this transducer with the intersection of transducers in v.

If invert is true, then compose the intersection of the transducers in v with this transducer.

The algorithm used by this function is faster than intersecting all transducers one by one and then composing this transducer with the intersection.

Precondition
The transducers in v are deterministic and epsilon-free.
Parameters
vA tuple of transducers.
invertWhether the intersection of the transducers in v is composed with this transducer.
def concatenate (   self,
  another 
)

Concatenate this transducer with another.

def conjunct (   self,
  another 
)

Alias for intersect.

See also
hfst.HfstTransducer.intersect
def convert (   self,
  type,
  options = '' 
)

Convert the transducer into an equivalent transducer in format type.

If a weighted transducer is converted into an unweighted one, all weights are lost. In the reverse case, all weights are initialized to the semiring's one.

A transducer of type hfst.types.SFST_TYPE, hfst.types.TROPICAL_OPENFST_TYPE, hfst.types.LOG_OPENFST_TYPE or hfst.types.FOMA_TYPE can be converted into an hfst.types.HFST_OL_TYPE or hfst.types.HFST_OLW_TYPE transducer, but an hfst.types.HFST_OL_TYPE or hfst.types.HFST_OLW_TYPE transducer cannot be converted to any other type.

Note
For conversion between HfstBasicTransducer and HfstTransducer, see hfst.HfstTransducer.__init__ and hfst.HfstBasicTransducer.__init__
def copy (   self)

Return a deep copy of the transducer.

 tr = hfst.regex('[foo:bar::0.3]*')
 TR = tr.copy()
 assert(tr.compare(TR))
def cross_product (   self,
  another 
)

Make cross product of this transducer with another.

It pairs every string of this with every string of another. If strings are not the same length, epsilon padding will be added in the end of the shorter string.

Precondition
Both transducers must be automata, i.e. map strings onto themselves.
def determinize (   self)

Determinize the transducer.

Determinizing a transducer yields an equivalent transducer that has no state with two or more transitions whose input:output symbol pairs are the same.

def disjunct (   self,
  another 
)

Disjunct this transducer with another.

def eliminate_flag (   self,
  symbol 
)

Eliminate flag diacritic symbol from the transducer.

Parameters
symbolThe flag to be eliminated. TODO: explain more.

An equivalent transducer with no flags symbol.

def eliminate_flags (   self,
  symbols 
)

Eliminate flag diacritics listed in symbols from the transducer.

Parameters
symbolsThe flags to be eliminated. TODO: explain more.

An equivalent transducer with no flags listed in symbols.

def extract_longest_paths (   kvargs)

Extract longest paths of the transducer.

Returns
A dictionary.
def extract_paths (   self,
  kvargs 
)

Extract paths that are recognized by the transducer.

Parameters
kvargsArguments recognized are filter_flags, max_cycles, max_number, obey_flags, output, random.
filter_flagsWhether flags diacritics are filtered out from the result (default True).
max_cyclesIndicates how many times a cycle will be followed, with negative numbers indicating unlimited (default -1 i.e. unlimited).
max_numberThe total number of resulting strings is capped at this value, with 0 or negative indicating unlimited (default -1 i.e. unlimited).
obey_flagsWhether flag diacritics are validated (default True).
outputOutput format. Values recognized: 'text' (as a string, separated by newlines), 'raw' (a dictionary that maps each input string into a list of tuples of an output string and a weight), 'dict' (a dictionary that maps each input string into a tuple of tuples of an output string and a weight, the default).
randomWhether result strings are fetched randomly (default False).
Returns
The extracted strings. output controls how they are represented.
Precondition
The transducer must be acyclic, if both max_number and max_cycles have unlimited values. Else a hfst.exceptions.TransducerIsCyclicException will be thrown.

An example:

 >>> tr = hfst.regex('a:b+ (a:c+)')
 >>> print(tr)
 0       1       a       b       0.000000
 1       1       a       b       0.000000
 1       2       a       c       0.000000
 1       0.000000
 2       2       a       c       0.000000
 2       0.000000

 >>> print(tr.extract_paths(max_cycles=1, output='text'))
 a:b     0
 aa:bb   0
 aaa:bbc 0
 aaaa:bbcc       0
 aa:bc   0
 aaa:bcc 0

 >>> print(tr.extract_paths(max_number=4, output='text'))
 a:b     0
 aa:bc   0
 aaa:bcc 0
 aaaa:bccc       0
 
 >>> print(tr.extract_paths(max_cycles=1, max_number=4, output='text'))
 a:b     0
 aa:bb   0
 aa:bc   0
 aaa:bcc 0
Exceptions
TransducerIsCyclicException
See also
hfst.HfstTransducer.n_best
Note
Special symbols are printed as such.
Todo:
a link to flag diacritics
def extract_shortest_paths ( )

Extract shortest paths of the transducer.

Returns
A dictionary.
def get_alphabet (   self)

Get the alphabet of the transducer.

The alphabet is defined as the set of symbols known to the transducer.

Returns
A tuple of strings.
def get_name (   self)

Get the name of the transducer.

See also
set_name
def get_properties (   self)

Get all properties from the transducer.

Returns
A dictionary whose keys are properties and whose values are the values of those properties.
def get_property (   self,
  property 
)

Get arbitrary string propert property.

Parameters
propertyThe name of the property whose value is returned. get_property('name') works like get_name().
def get_type (   self)

The implementation type of the transducer.

Returns
hfst.ImplementationType
def has_flag_diacritics (   self)

Whether the transducer has flag diacritics in its transitions.

def input_project (   self)

Extract the input language of the transducer.

All transition symbol pairs isymbol:osymbol are changed to isymbol:isymbol.

def insert_freely (   self,
  ins 
)

Freely insert a transition or a transducer into the transducer.

Parameters
insThe transition or transducer to be inserted.

If ins is a transition, i.e. a 2-tuple of strings: A transition is added to each state in this transducer. The transition leads from that state to itself with input and output symbols defined by ins. The weight of the transition is zero.

If ins is an hfst.HfstTransducer: A copy of ins is attached with epsilon transitions to each state of this transducer. After the operation, for each state S in this transducer, there is an epsilon transition that leads from state S to the initial state of ins, and for each final state of ins, there is an epsilon transition that leads from that final state to state S in this transducer. The weights of the final states in ins are copied to the epsilon transitions leading to state S.

def insert_to_alphabet (   self,
  symbol 
)

Explicitly insert symbol to the alphabet of the transducer.

Parameters
symbolThe symbol (string) to be inserted.
Note
Usually this function is not needed since new symbols are added to the alphabet by default.
def intersect (   self,
  another 
)

Intersect this transducer with another.

def invert (   self)

Swap the input and output symbols of each transition in the transducer.

def is_automaton (   self)

Whether each transition in the transducer has equivalent input and output symbols.

Note
Transition with hfst.UNKNOWN on both sides IS NOT a transition with equivalent input and output symbols.
Transition with hfst.IDENTITY on both sides IS a transition with equivalent input and output symbols.
def is_cyclic (   self)

Whether the transducer is cyclic.

def is_implementation_type_available (   type)

Whether HFST is linked to the transducer library needed by implementation type type.

def is_infinitely_ambiguous (   self)

Whether the transducer is infinitely ambiguous.

A transducer is infinitely ambiguous if there exists an input that will yield infinitely many results, i.e. there are input epsilon loops that are traversed with that input.

def is_lookup_infinitely_ambiguous (   self,
  tok_input 
)

Whether lookup of path input will have infinite results.

Currently, this function will return whether the transducer is infinitely ambiguous on any lookup path found in the transducer, i.e. the argument input is ignored.

Todo:
Do not ignore the argument input
def lenient_composition (   self,
  another 
)

Perform a lenient composition on this transducer and another.

TODO: explain more.

def longest_path_size (   kvargs)

Get length of longest path of the transducer.

def lookup (   self,
  input,
  kvargs 
)

Lookup string input.

Parameters
inputThe input.
kvargsPossible parameters and their default values are: obey_flags=True, max_number=-1, time_cutoff=0.0, output='tuple'
obey_flagsWhether flag diacritics are obeyed. Currently always True.
max_numberMaximum number of results returned, defaults to -1, i.e. infinity.
time_cutoffHow long the function can search for results before returning, expressed in seconds. Defaults to 0.0, i.e. infinitely.
outputPossible values are 'tuple', 'text' and 'raw', 'tuple' being the default.
Note
This function is implemented only for optimized lookup format (hfst.types.HFST_OL_TYPE or hfst.types.HFST_OLW_TYPE). Either convert to optimized lookup format or to HfstBasicTransducer if you wish to perform lookup. Conversion to OL might take a while but it lookup is fast. Conversion to HfstBasicTransducer is quick but lookup is slower.
def lookup_optimize (   self)

Optimize the transducer for lookup.

This effectively converts the transducer into hfst.types.HFST_OL_TYPE.

def minimize (   self)

Minimize the transducer.

Minimizing a transducer yields an equivalent transducer with the smallest number of states.

Bug:
OpenFst's minimization algorithm seems to add epsilon transitions to weighted transducers?
def minus (   self,
  another 
)

Alias for subtract.

See also
hfst.HfstTransducer.subtract
def n_best (   self,
  n 
)

Extract n best paths of the transducer.

In the case of a weighted transducer (hfst.types.TROPICAL_OPENFST_TYPE or hfst.types.LOG_OPENFST_TYPE), best paths are defined as paths with the lowest weight. In the case of an unweighted transducer (hfst.types.SFST_TYPE or hfst.types.FOMA_TYPE), the function returns random paths.

This function is not implemented for hfst.types.FOMA_TYPE or hfst.types.SFST_TYPE. If this function is called by an HfstTransducer of type hfst.types.FOMA_TYPE or hfst.types.SFST_TYPE, it is converted to hfst.types.TROPICAL_OPENFST_TYPE, paths are extracted and it is converted back to hfst.types.FOMA_TYPE or hfst.types.SFST_TYPE. If HFST is not linked to OpenFst library, an hfst.exceptions.ImplementationTypeNotAvailableException is thrown.

def number_of_arcs (   self)

The number of transitions in the transducer.

def number_of_states (   self)

The number of states in the transducer.

def optionalize (   self)

Disjunct the transducer with an epsilon transducer.

def output_project (   self)

Extract the output language of the transducer.

All transition symbol pairs isymbol:osymbol are changed to osymbol:osymbol.

def priority_union (   self,
  another 
)

Make priority union of this transducer with another.

For the operation t1.priority_union(t2), the result is a union of t1 and t2, except that whenever t1 and t2 have the same string on left side, the path in t2 overrides the path in t1.

Example

 Transducer 1 (t1):
 a : a
 b : b
 
 Transducer 2 (t2):
 b : B
 c : C
 
 Result ( t1.priority_union(t2) ):
 a : a
 b : B
 c : C

For more information, read fsmbook.

def prune (   self)

Make transducer coaccessible.

A transducer is coaccessible iff there is a path from every state to a final state.

def push_weights_to_end (   self)

Push weights towards final state(s).

If the HfstTransducer is of unweighted type (hfst.types.SFST_TYPE or hfst.types.FOMA_TYPE), nothing is done.

An example:

 >>> import hfst
 >>> tr = hfst.regex('[a::1 a:b::0.3 (b::0)]::0.7;')
 >>> tr.push_weights_to_end()
 >>> print(tr)
 0       1       a       a       0.000000
 1       2       a       b       0.000000
 2       3       b       b       0.000000
 2       2.000000
 3       2.000000
See also
hfst.HfstTransducer.push_weights_to_start
def push_weights_to_start (   self)

Push weights towards initial state.

If the HfstTransducer is of unweighted type (hfst.types.SFST_TYPE or hfst.types.FOMA_TYPE), nothing is done.

An example:

 >>> import hfst
 >>> tr = hfst.regex('[a::1 a:b::0.3 (b::0)]::0.7;')
 >>> tr.push_weights_to_start()
 >>> print(tr)
 0       1       a       a       2.000000
 1       2       a       b       0.000000
 2       3       b       b       0.000000
 2       0.000000
 3       0.000000
See also
hfst.HfstTransducer.push_weights_to_end
def remove_epsilons (   self)

Remove all epsilon:epsilon transitions from the transducer so that the resulting transducer is equivalent to the original one.

def remove_from_alphabet (   self,
  symbol 
)

Remove symbol from the alphabet of the transducer.

Parameters
symbolThe symbol (string) to be removed.
Precondition
symbol does not occur in any transition of the transducer.
Note
Use with care, removing a symbol that occurs in a transition of the transducer can have unexpected results.
def remove_optimization (   self)

Remove lookup optimization.

This effectively converts transducer (back) into default fst type.

def repeat_n (   self,
  n 
)

A concatenation of n transducers.

def repeat_n_minus (   self,
  n 
)

A concatenation of N transducers where N is any number from zero to n, inclusive.

def repeat_n_plus (   self,
  n 
)

A concatenation of N transducers where N is any number from n to infinity, inclusive.

def repeat_n_to_k (   self,
  n,
  k 
)

A concatenation of N transducers where N is any number from n to k, inclusive.

def repeat_plus (   self)

A concatenation of N transducers where N is any number from one to infinity.

def repeat_star (   self)

A concatenation of N transducers where N is any number from zero to infinity.

def reverse (   self)

Reverse the transducer.

A reverted transducer accepts the string 'n(0) n(1) ... n(N)' iff the original transducer accepts the string 'n(N) n(N-1) ... n(0)'

def set_final_weights (   self,
  weight 
)

Set the weights of all final states to weight.

If the HfstTransducer is of unweighted type (hfst.types.SFST_TYPE or hfst.types.FOMA_TYPE), nothing is done.

def set_name (   self,
  name 
)

Rename the transducer name.

Parameters
nameThe name of the transducer.
See also
get_name
def set_property (   self,
  property,
  value 
)

Set arbitrary string property property to value.

Parameters
propertyA string naming the property.
valueA string expressing the value of property.

set_property('name', 'name of the transducer') equals set_name('name of the transducer').

Note
While this function is capable of creating endless amounts of arbitrary metadata, it is suggested that property names are drawn from central repository, or prefixed with "x-". A property that does not follow this convention may affect the behavior of transducer in future releases.
def shuffle (   self,
  another 
)

Shuffle this transducer with transducer another.

If transducer A accepts string 'foo' and transducer B string 'bar', the transducer that results from shuffling A and B accepts all strings [(f|b)(o|a)(o|r)].

Precondition
Both transducers must be automata, i.e. map strings onto themselves.
def substitute (   self,
  s,
  S = None,
  kvargs 
)

Substitute symbols or transitions in the transducer.

Parameters
sThe symbol or transition to be substituted. Can also be a dictionary of substitutions, if S == None.
SThe symbol, transition, a tuple of transitions or a transducer (hfst.HfstTransducer) that substitutes s.
kvargsArguments recognized are 'input' and 'output', their values can be False or True, True being the default. These arguments are valid only if s and S are strings, else they are ignored.
inputWhether substitution is performed on input side, defaults to True. Valid only if s and S are strings.
outputWhether substitution is performed on output side, defaults to True. Valid only if s and \ S are strings.

For more information, see hfst.HfstBasicTransducer.substitute. The function works similarly, with the exception of argument S, which must be hfst.HfstTransducer instead of hfst.HfstBasicTransducer.

See also
hfst.HfstBasicTransducer.substitute
def subtract (   self,
  another 
)

Subtract transducer another from this transducer.

def write (   self,
  ostr 
)

Write the transducer in binary format to ostr.

Parameters
ostrA hfst.HfstOutputStream where the transducer is written.
def write_att (   self,
  f,
  write_weights = True 
)

Write the transducer in AT&T format to file f, write_weights defined whether weights are written.

Parameters
fA python file where transducer is written.
write_weightsWhether weights are written.
def write_att (   self,
  ofile,
  write_weights = True 
)

Write the transducer in AT&T format to file ofile, write_weights defines whether weights are written.

The fields in the resulting AT&T format are separated by tabulator characters.

NOTE: If the transition symbols contain space characters,the spaces are printed as '@_SPACE_@' because whitespace characters are used as field separators in AT&T format. Epsilon symbols are printed as '@0@'.

If several transducers are written in the same file, they must be separated by a line of two consecutive hyphens "--", so that they will be read correctly by hfst.read_att.

An example:

 tr1 = hfst.regex('[foo:bar baz:0 " "]::0.3')
 tr2 = hfst.empty_fst()
 tr3 = hfst.epsilon_fst(0.5)
 tr4 = hfst.regex('[foo]')
 tr5 = hfst.empty_fst()
 
 f = hfst.hfst_open('testfile.att', 'w')
 for tr in [tr1, tr2, tr3, tr4]:
     tr.write_att(f)
     f.write('--\n')
 tr5.write_att(f)
 f.close()

This will yield a file 'testfile.att' that looks as follows:

 0       1       foo     bar     0.299805
 1       2       baz     @0@     0.000000
 2       3       @_SPACE_@       @_SPACE_@       0.000000
 3       0.000000
 --
 --
 0       0.500000
 --
 0       1       foo     foo     0.000000
 1       0.000000
 --
Exceptions
StreamCannotBeWrittenException
StreamIsClosedException
See also
hfst.HfstOutputStream.write
hfst.HfstTransducer.__init__
def write_att (   self,
  filename,
  write_weights = True 
)

Write the transducer in AT&T format to file named filename.

write_weights defines whether weights are written.

If the file exists, it is overwritten. If the file does not exist, it is created.

def write_prolog (   f,
  name,
  write_weights = True 
)

Write the transducer in prolog format with name name to file f, write_weights defined whether weights are written.

Parameters
fA python file where the transducer is written.
nameThe name of the transducer that must be given in a prolog file.
write_weightsWhether weights are written.

The documentation for this class was generated from the following file: