Parsing Messages¶
To parse a FIX message, first create an instance of the FixParser class.
1 | parser = simplefix.FixParser() |
To extract FIX messages from a byte buffer, such as that received from a
socket, you should append it to the internal reassembly buffer using
append_buffer()
. At any time, you can call get_message()
: if there’s
no complete message in the parser’s internal buffer, it’ll return None
,
otherwise, it’ll return a FixMessage
instance.
1 2 | parser.append_buffer(response_from_socket) message = parser.get_message() |
Once you’ve received a FixMessage
from get_message()
, you can: check
the number of fields with count()
, retrieve the value of a field using
get()
or the built-in [ ]
syntax, or iterate over all the fields
using for ... in ...
.
1 2 3 4 5 6 7 8 | message.count(49) >>> 1 message.get(35) >>> 'A' message["35"] >>> 'A' |
Members of repeating groups can be accessed using get(tag, nth)
, where the
“nth” value is an integer indicating the number of the group to use (note
that the first group is number one, not zero).
1 2 | message = get(9061, 2) >>> 22 |
Parser Options¶
By default, the parser is quite forgiving, and will attempt to extract FIX messages from the supplied buffer ignoring strict adherence to the standard.
In some cases however, it can be useful to instruct the parser to be more or less strict in particular ways, depending on the protocol implementation you’re dealing with.
The parser’s constructor accepts several different keyword arguments, each controlling a specific aspect of the parser’s behaviour. These options can also be configured using individual functions on the parser object.
Empty Values¶
The FIX standards explicitly prohibit the use of empty (zero-length) values. In practice however, these are sometimes seen, and this option allows them to be parsed.
For example, a message like
would, by default, raise the EmptyValueError
exception. This option
prevents that exception, and returns an empty string value instead.
1 | parser = simplefix.FixParser(allow_empty_values=True) |
or
1 2 | parser = simplefix.FixParser() parser.set_allow_empty_values(True) |
Missing BeginString¶
The BeginString(8) tag is required by the standard to be the first field of all messages: always present, and always first. By default, the parser ensures that this is the case. This option disables that check.
1 | parser = simplefix.FixParser(allow_missing_begin_string=True) |
or
1 2 | parser = simplefix.FixParser() parser.set_allow_missing_begin_string(True) |
Note: see Strip Fields Before BeginString below for restrictions on combining that with this option.
Strip Fields Before BeginString¶
In some cases, message reception timestamps, inbound/outbound direction flags, or other data might be encoded as “FIX” fields prior to the BeginString(8). This option instructs the parser to discard any fields found before the BeginString(8) when parsing.
1 | parser = simplefix.FixParser(strip_fields_before_begin_string=True) |
or
1 2 | parser = simplefix.FixParser() parser.set_strip_fields_before_begin_string(True) |
Note: this option cannot be combined with
allow_missing_begin_string
as it requires a BeginString(8) field
to stop stripping.
Parser Errors¶
The get_message()
method on the parser attempts to decode a FIX
message from its internal reassembly buffer. It is not an error for
there to be no message or an incomplete message to be in the
reassembly buffer when it is called. In these cases, get_message()
will simply return None
.
However, if the parser is unable to successfully decode a message, or if any configured validation checks fail, the parser will raise an exception to report the problem.
Possible exceptions are:
-
exception
EmptyValueError
¶ The parser read a field where the equals-sign was followed immediately by the field terminator byte (
SOH
). This is not permitted by the FIX standard.Use the
allow_empty_values
parser option override this prohibition.
-
exception
FieldOrderError
¶ The FIX standard requires messages to contain some tags in a specific order and position. For instance, BeginString(8), BodyLength(9), and MsgType(35) must occur in that order at the start of the message.
This exception indicates that a tag was seen in an unexpected order or a tag was not seen where it was expected.
-
exception
IncompleteTagError
¶ When the parser is configured with
stop_byte
, this exception indicates that the stop byte was read part-way through reading a tag – that is, following a field terminator (SOH
), and one or more tag digits, but before the equals sign.This normally indicates a corrupted message.
-
exception
RawLengthNotNumberError
¶ Raw data is encoded using two fields: a length field followed by the value field. This exception indicates that a field whose tag number is registered as being a raw data length field was parsed, but that its value could not be decoded as a positive integer as expected.
Usually, this means that the message being parsed uses a tag number that the FIX standard reserves as a raw data length field, but is here being used for another purpose.
See
simplefix.FixParser.remove_raw()
for a way to change the set of tag numbers expected to be raw data lengths and values.
-
exception
TagNotNumberError
¶ A field was parsed where the tag value, between the previous field terminator byte (
SOH
) and the equals-sign, could not be converted to a positive integer.This normally results from a corrupted message, often during development but usually rare in production. It might suggest problems reassembling the byte stream from the socket layer.