itchfeed 1.0.4__tar.gz → 1.0.5__tar.gz

{itchfeed-1.0.4/itchfeed.egg-info → itchfeed-1.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: itchfeed
-Version: 1.0.4
+Version: 1.0.5
 Summary: Simple parser for ITCH messages
 Home-page: https://github.com/bbalouki/itch
 Download-URL: https://pypi.org/project/itchfeed/
@@ -59,7 +59,7 @@ Dynamic: summary
 *   [Data Representation](#data-representation)
     *   [Common Attributes of `MarketMessage`](#common-attributes-of-marketmessage)
     *   [Common Methods of `MarketMessage`](#common-methods-of-marketmessage)
-    *   [Serializing Messages with `pack()`](#serializing-messages-with-pack)
+    *   [Serializing Messages with `to_bytes()`](#serializing-messages-with-to_bytes)
     *   [Data Types in Parsed Messages](#data-types-in-parsed-messages)
 *   [Error Handling](#error-handling)
     *   [Handling Strategies](#handling-strategies)
@@ -170,8 +170,8 @@ try:
 
 except FileNotFoundError:
     print(f"Error: File not found at {itch_file_path}")
-except Exception as e:
-    print(f"An error occurred: {e}")
+except ValueError as e:
+    print(f"An error occurred during parsing: {e}")
 
 ```
 
@@ -276,10 +276,10 @@ for message_type, sample_data in TEST_DATA.items():
     print(f"Creating message of type {message_type}")
     message = create_message(message_type, **sample_data)
     print(f"Created message: {message}")
-    print(f"Packed message: {message.pack()}")
+    print(f"Packed message: {message.to_bytes()}")
     print(f"Message size: {message.message_size}")
     print(f"Message Attributes: {message.get_attributes()}")
-    assert len(message.pack()) ==  message.message_size
+    assert len(message.to_bytes()) ==  message.message_size
     print()
 ```
 
@@ -388,14 +388,14 @@ The `MarketMessage` base class, and therefore all specific message classes, prov
     *   Returns a dictionary of all attributes (fields) of the message instance, along with their current values.
     *   This can be useful for generic inspection or logging of message contents without needing to know the specific type of the message beforehand.
 
-### Serializing Messages with `pack()`
+### Serializing Messages with `to_bytes()`
 
-Each specific message class (e.g., `SystemEventMessage`, `AddOrderNoMPIAttributionMessage`) also provides a `pack()` method. This method is the inverse of the parsing process.
+Each specific message class (e.g., `SystemEventMessage`, `AddOrderNoMPIAttributionMessage`) also provides a `to_bytes()` method. This method is the inverse of the parsing process.
 
 *   **Purpose:** It serializes the message object, with its current attribute values, back into its raw ITCH 5.0 binary format. The output is a `bytes` object representing the exact byte sequence that would appear in an ITCH data feed for that message.
 *   **Usefulness:**
     *   **Generating Test Data:** Create custom ITCH messages for testing your own ITCH processing applications.
-    *   **Modifying Messages:** Parse an existing message, modify some of its attributes, and then `pack()` it back into binary form.
+    *   **Modifying Messages:** Parse an existing message, modify some of its attributes, and then `to_bytes()` it back into binary form.
     *   **Creating Custom ITCH Feeds:** While more involved, you could use this to construct sequences of ITCH messages for specialized scenarios.
 
 **Example:**
@@ -415,21 +415,21 @@ import time
 #     for packing requires setting attributes manually if not using raw bytes for construction)
 
 event_msg = SystemEventMessage.__new__(SystemEventMessage) # Create instance without calling __init__
-event_msg.message_type = b'S' # Must be set for pack() to know its type
+event_msg.message_type = b'S' # Must be set for to_bytes() to know its type
 event_msg.stock_locate = 0 # Placeholder or actual value
 event_msg.tracking_number = 0 # Placeholder or actual value
 event_msg.event_code = b'O' # Example: Start of Messages
 
 # 2. Set the timestamp.
 #    The `timestamp` attribute (nanoseconds since midnight) must be set.
-#    The `pack()` method will internally use `split_timestamp()` to get the parts.
+#    The `to_bytes()` method will internally use `split_timestamp()` to get the parts.
 current_nanoseconds = int(time.time() * 1e9) % (24 * 60 * 60 * int(1e9))
 event_msg.timestamp = current_nanoseconds # Directly set the nanosecond timestamp
 
 # 3. Pack the message into binary format.
-#    The pack() method prepends the message type and then packs stock_locate,
+#    The to_bytes() method prepends the message type and then packs stock_locate,
 #    tracking_number, the split timestamp, and then the message-specific fields.
-packed_bytes = event_msg.pack()
+packed_bytes = event_msg.to_bytes()
 
 # 4. The result is a bytes object
 print(f"Packed {len(packed_bytes)} bytes: {packed_bytes.hex().upper()}")

{itchfeed-1.0.4 → itchfeed-1.0.5}/README.md

@@ -23,7 +23,7 @@
 *   [Data Representation](#data-representation)
     *   [Common Attributes of `MarketMessage`](#common-attributes-of-marketmessage)
     *   [Common Methods of `MarketMessage`](#common-methods-of-marketmessage)
-    *   [Serializing Messages with `pack()`](#serializing-messages-with-pack)
+    *   [Serializing Messages with `to_bytes()`](#serializing-messages-with-to_bytes)
     *   [Data Types in Parsed Messages](#data-types-in-parsed-messages)
 *   [Error Handling](#error-handling)
     *   [Handling Strategies](#handling-strategies)
@@ -134,8 +134,8 @@ try:
 
 except FileNotFoundError:
     print(f"Error: File not found at {itch_file_path}")
-except Exception as e:
-    print(f"An error occurred: {e}")
+except ValueError as e:
+    print(f"An error occurred during parsing: {e}")
 
 ```
 
@@ -240,10 +240,10 @@ for message_type, sample_data in TEST_DATA.items():
     print(f"Creating message of type {message_type}")
     message = create_message(message_type, **sample_data)
     print(f"Created message: {message}")
-    print(f"Packed message: {message.pack()}")
+    print(f"Packed message: {message.to_bytes()}")
     print(f"Message size: {message.message_size}")
     print(f"Message Attributes: {message.get_attributes()}")
-    assert len(message.pack()) ==  message.message_size
+    assert len(message.to_bytes()) ==  message.message_size
     print()
 ```
 
@@ -352,14 +352,14 @@ The `MarketMessage` base class, and therefore all specific message classes, prov
     *   Returns a dictionary of all attributes (fields) of the message instance, along with their current values.
     *   This can be useful for generic inspection or logging of message contents without needing to know the specific type of the message beforehand.
 
-### Serializing Messages with `pack()`
+### Serializing Messages with `to_bytes()`
 
-Each specific message class (e.g., `SystemEventMessage`, `AddOrderNoMPIAttributionMessage`) also provides a `pack()` method. This method is the inverse of the parsing process.
+Each specific message class (e.g., `SystemEventMessage`, `AddOrderNoMPIAttributionMessage`) also provides a `to_bytes()` method. This method is the inverse of the parsing process.
 
 *   **Purpose:** It serializes the message object, with its current attribute values, back into its raw ITCH 5.0 binary format. The output is a `bytes` object representing the exact byte sequence that would appear in an ITCH data feed for that message.
 *   **Usefulness:**
     *   **Generating Test Data:** Create custom ITCH messages for testing your own ITCH processing applications.
-    *   **Modifying Messages:** Parse an existing message, modify some of its attributes, and then `pack()` it back into binary form.
+    *   **Modifying Messages:** Parse an existing message, modify some of its attributes, and then `to_bytes()` it back into binary form.
     *   **Creating Custom ITCH Feeds:** While more involved, you could use this to construct sequences of ITCH messages for specialized scenarios.
 
 **Example:**
@@ -379,21 +379,21 @@ import time
 #     for packing requires setting attributes manually if not using raw bytes for construction)
 
 event_msg = SystemEventMessage.__new__(SystemEventMessage) # Create instance without calling __init__
-event_msg.message_type = b'S' # Must be set for pack() to know its type
+event_msg.message_type = b'S' # Must be set for to_bytes() to know its type
 event_msg.stock_locate = 0 # Placeholder or actual value
 event_msg.tracking_number = 0 # Placeholder or actual value
 event_msg.event_code = b'O' # Example: Start of Messages
 
 # 2. Set the timestamp.
 #    The `timestamp` attribute (nanoseconds since midnight) must be set.
-#    The `pack()` method will internally use `split_timestamp()` to get the parts.
+#    The `to_bytes()` method will internally use `split_timestamp()` to get the parts.
 current_nanoseconds = int(time.time() * 1e9) % (24 * 60 * 60 * int(1e9))
 event_msg.timestamp = current_nanoseconds # Directly set the nanosecond timestamp
 
 # 3. Pack the message into binary format.
-#    The pack() method prepends the message type and then packs stock_locate,
+#    The to_bytes() method prepends the message type and then packs stock_locate,
 #    tracking_number, the split timestamp, and then the message-specific fields.
-packed_bytes = event_msg.pack()
+packed_bytes = event_msg.to_bytes()
 
 # 4. The result is a bytes object
 print(f"Packed {len(packed_bytes)} bytes: {packed_bytes.hex().upper()}")

{itchfeed-1.0.4 → itchfeed-1.0.5}/itch/messages.py

@@ -13,13 +13,21 @@ class MarketMessage(object):
 
     All Message have the following attributes:
     - message_type: A single letter that identify the message
+    - timestamp: Time at which the message was generated (Nanoseconds past midnight)
+    - stock_locate: Locate code identifying the security
+    - tracking_number: Nasdaq internal tracking number
+
+    The following attributes are not part of the message, but are used to describe the message:
     - description: Describe the message
     - message_format: string format using to unpack the message
     - message_pack_format: string format using to pack the message
     - message_size: The size in bytes of the message
-    - timestamp: Time at which the message was generated (Nanoseconds past midnight)
-    - stock_locate: Locate code identifying the security
-    - tracking_number: Nasdaq internal tracking number
+
+    # NOTE:
+    Prices are integers fields supplied with an associated precision.  When converted to a decimal format, prices are in 
+    fixed point format, where the precision defines the number of decimal places. For example, a field flagged as Price 
+    (4) has an implied 4 decimal places.  The maximum value of price (4) in TotalView ITCH is 200,000.0000 (decimal, 
+    77359400 hex). ``price_precision`` is 4 for all messages except MWCBDeclineLeveMessage where ``price_precision`` is 8.
     """
 
     message_type: bytes
@@ -32,13 +40,24 @@ class MarketMessage(object):
     tracking_number: int
     price_precision: int = 4
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return repr(self.decode())
 
-    def pack(self) -> bytes:
+    def __bytes__(self) -> bytes:
+        return self.to_bytes()
+
+    def to_bytes(self) -> bytes:
         """
         Packs the message into bytes using the defined message_pack_format.
         This method should be overridden by subclasses to include specific fields.
+
+        Note:
+            All packed messages do not include 
+            - ``description``, 
+            - ``message_format``, 
+            - ``message_pack_format``, 
+            - ``message_size`` 
+            - ``price_precision``
         """
         pass
 
@@ -166,7 +185,7 @@ class SystemEventMessage(MarketMessage):
         ) = struct.unpack(self.message_format, message[1:])
         self.set_timestamp(timestamp1, timestamp2)
 
-    def pack(self):
+    def to_bytes(self):
         (timestamp1, timestamp2) = self.split_timestamp()
         message = struct.pack(
             self.message_pack_format,
@@ -288,7 +307,7 @@ class StockDirectoryMessage(MarketMessage):
         ) = struct.unpack(self.message_format, message[1:])
         self.set_timestamp(timestamp1, timestamp2)
 
-    def pack(self):
+    def to_bytes(self):
         (timestamp1, timestamp2) = self.split_timestamp()
         message = struct.pack(
             self.message_pack_format,
@@ -368,7 +387,7 @@ class StockTradingActionMessage(MarketMessage):
         ) = struct.unpack(self.message_format, message[1:])
         self.set_timestamp(timestamp1, timestamp2)
 
-    def pack(self):
+    def to_bytes(self):
         (timestamp1, timestamp2) = self.split_timestamp()
         message = struct.pack(
             self.message_pack_format,
@@ -429,7 +448,7 @@ class RegSHOMessage(MarketMessage):
         ) = struct.unpack(self.message_format, message[1:])
         self.set_timestamp(timestamp1, timestamp2)
 
-    def pack(self):
+    def to_bytes(self):
         (timestamp1, timestamp2) = self.split_timestamp()
         message = struct.pack(
             self.message_pack_format,
@@ -491,7 +510,7 @@ class MarketParticipantPositionMessage(MarketMessage):
         ) = struct.unpack(self.message_format, message[1:])
         self.set_timestamp(timestamp1, timestamp2)
 
-    def pack(self):
+    def to_bytes(self):
         (timestamp1, timestamp2) = self.split_timestamp()
         message = struct.pack(
             self.message_pack_format,
@@ -542,7 +561,7 @@ class MWCBDeclineLeveMessage(MarketMessage):
         ) = struct.unpack(self.message_format, message[1:])
         self.set_timestamp(timestamp1, timestamp2)
 
-    def pack(self):
+    def to_bytes(self):
         (timestamp1, timestamp2) = self.split_timestamp()
         message = struct.pack(
             self.message_pack_format,
@@ -587,7 +606,7 @@ class MWCBStatusMessage(MarketMessage):
         ) = struct.unpack(self.message_format, message[1:])
         self.set_timestamp(timestamp1, timestamp2)
 
-    def pack(self):
+    def to_bytes(self):
         (timestamp1, timestamp2) = self.split_timestamp()
         message = struct.pack(
             self.message_pack_format,
@@ -648,7 +667,7 @@ class IPOQuotingPeriodUpdateMessage(MarketMessage):
         ) = struct.unpack(self.message_format, message[1:])
         self.set_timestamp(timestamp1, timestamp2)
 
-    def pack(self):
+    def to_bytes(self):
         (timestamp1, timestamp2) = self.split_timestamp()
         message = struct.pack(
             self.message_pack_format,
@@ -704,7 +723,7 @@ class LULDAuctionCollarMessage(MarketMessage):
         ) = struct.unpack(self.message_format, message[1:])
         self.set_timestamp(timestamp1, timestamp2)
 
-    def pack(self):
+    def to_bytes(self):
         (timestamp1, timestamp2) = self.split_timestamp()
         message = struct.pack(
             self.message_pack_format,
@@ -769,7 +788,7 @@ class OperationalHaltMessage(MarketMessage):
         ) = struct.unpack(self.message_format, message[1:])
         self.set_timestamp(timestamp1, timestamp2)
 
-    def pack(self):
+    def to_bytes(self):
         (timestamp1, timestamp2) = self.split_timestamp()
         message = struct.pack(
             self.message_pack_format,
@@ -832,7 +851,7 @@ class AddOrderNoMPIAttributionMessage(AddOrderMessage):
         ) = struct.unpack(self.message_format, message[1:])
         self.set_timestamp(timestamp1, timestamp2)
 
-    def pack(self):
+    def to_bytes(self):
         (timestamp1, timestamp2) = self.split_timestamp()
         message = struct.pack(
             self.message_pack_format,
@@ -886,7 +905,7 @@ class AddOrderMPIDAttribution(AddOrderMessage):
         ) = struct.unpack(self.message_format, message[1:])
         self.set_timestamp(timestamp1, timestamp2)
 
-    def pack(self):
+    def to_bytes(self):
         (timestamp1, timestamp2) = self.split_timestamp()
         message = struct.pack(
             self.message_pack_format,
@@ -957,7 +976,7 @@ class OrderExecutedMessage(ModifyOrderMessage):
         ) = struct.unpack(self.message_format, message[1:])
         self.set_timestamp(timestamp1, timestamp2)
 
-    def pack(self):
+    def to_bytes(self):
         (timestamp1, timestamp2) = self.split_timestamp()
         message = struct.pack(
             self.message_pack_format,
@@ -1025,7 +1044,7 @@ class OrderExecutedWithPriceMessage(ModifyOrderMessage):
         ) = struct.unpack(self.message_format, message[1:])
         self.set_timestamp(timestamp1, timestamp2)
 
-    def pack(self):
+    def to_bytes(self):
         (timestamp1, timestamp2) = self.split_timestamp()
         message = struct.pack(
             self.message_pack_format,
@@ -1071,7 +1090,7 @@ class OrderCancelMessage(ModifyOrderMessage):
         ) = struct.unpack(self.message_format, message[1:])
         self.set_timestamp(timestamp1, timestamp2)
 
-    def pack(self):
+    def to_bytes(self):
         (timestamp1, timestamp2) = self.split_timestamp()
         message = struct.pack(
             self.message_pack_format,
@@ -1111,7 +1130,7 @@ class OrderDeleteMessage(ModifyOrderMessage):
         ) = struct.unpack(self.message_format, message[1:])
         self.set_timestamp(timestamp1, timestamp2)
 
-    def pack(self):
+    def to_bytes(self):
         (timestamp1, timestamp2) = self.split_timestamp()
         message = struct.pack(
             self.message_pack_format,
@@ -1164,7 +1183,7 @@ class OrderReplaceMessage(ModifyOrderMessage):
         ) = struct.unpack(self.message_format, message[1:])
         self.set_timestamp(timestamp1, timestamp2)
 
-    def pack(self):
+    def to_bytes(self):
         (timestamp1, timestamp2) = self.split_timestamp()
         message = struct.pack(
             self.message_pack_format,
@@ -1238,7 +1257,7 @@ class NonCrossTradeMessage(TradeMessage):
         ) = struct.unpack(self.message_format, message[1:])
         self.set_timestamp(timestamp1, timestamp2)
 
-    def pack(self):
+    def to_bytes(self):
         (timestamp1, timestamp2) = self.split_timestamp()
         message = struct.pack(
             self.message_pack_format,
@@ -1309,7 +1328,7 @@ class CrossTradeMessage(TradeMessage):
         ) = struct.unpack(self.message_format, message[1:])
         self.set_timestamp(timestamp1, timestamp2)
 
-    def pack(self):
+    def to_bytes(self):
         (timestamp1, timestamp2) = self.split_timestamp()
         message = struct.pack(
             self.message_pack_format,
@@ -1359,7 +1378,7 @@ class BrokenTradeMessage(TradeMessage):
         ) = struct.unpack(self.message_format, message[1:])
         self.set_timestamp(timestamp1, timestamp2)
 
-    def pack(self):
+    def to_bytes(self):
         (timestamp1, timestamp2) = self.split_timestamp()
         message = struct.pack(
             self.message_pack_format,
@@ -1441,7 +1460,7 @@ class NOIIMessage(MarketMessage):
         ) = struct.unpack(self.message_format, message[1:])
         self.set_timestamp(timestamp1, timestamp2)
 
-    def pack(self):
+    def to_bytes(self):
         (timestamp1, timestamp2) = self.split_timestamp()
         message = struct.pack(
             self.message_pack_format,
@@ -1496,7 +1515,7 @@ class RetailPriceImprovementIndicator(MarketMessage):
         ) = struct.unpack(self.message_format, message[1:])
         self.set_timestamp(timestamp1, timestamp2)
 
-    def pack(self):
+    def to_bytes(self):
         (timestamp1, timestamp2) = self.split_timestamp()
         message = struct.pack(
             self.message_pack_format,
@@ -1559,7 +1578,7 @@ class DLCRMessage(MarketMessage):
         ) = struct.unpack(self.message_format, message[1:])
         self.set_timestamp(timestamp1, timestamp2)
 
-    def pack(self):
+    def to_bytes(self):
         (timestamp1, timestamp2) = self.split_timestamp()
         message = struct.pack(
             self.message_pack_format,
@@ -1579,8 +1598,8 @@ class DLCRMessage(MarketMessage):
         )
         return message
 
-
-messages: Dict[bytes, Type[MarketMessage]] = {
+messages: Dict[bytes, Type[MarketMessage]]
+messages = {
     b"S": SystemEventMessage,
     b"R": StockDirectoryMessage,
     b"H": StockTradingActionMessage,
@@ -1607,7 +1626,7 @@ messages: Dict[bytes, Type[MarketMessage]] = {
 }
 
 
-def create_message(message_type: bytes, **kwargs) -> Type[MarketMessage]:
+def create_message(message_type: bytes, **kwargs) -> MarketMessage:
     """
     Creates a new message of a given type with specified attributes.
 

itchfeed-1.0.5/itch/parser.py

@@ -0,0 +1,192 @@
+from typing import IO, BinaryIO, Iterator
+
+from itch.messages import MESSAGES, MarketMessage
+from itch.messages import messages as msgs
+
+
+class MessageParser(object):
+    """
+    A market message parser for ITCH 5.0 data.
+
+    """
+
+    def __init__(self, message_type: bytes = MESSAGES):
+        self.message_type = message_type
+
+    def read_message_from_file(
+        self, file: BinaryIO, cachesize: int = 65_536, save_file: IO = None
+    ) -> Iterator[MarketMessage]:
+        """
+        Reads and parses market messages from a binary file-like object.
+
+        This method processes binary data in chunks, extracts individual messages
+        according to a specific format, and returns a list of successfully decoded
+        MarketMessage objects. Parsing stops either when the end of the file is
+        reached or when a system message with an end-of-messages event code is encountered.
+
+        Args:
+            file (BinaryIO):
+                A binary file-like object (opened in binary mode) from which market messages are read.
+            cachesize (int, optional):
+                The size of each data chunk to read. Defaults to 65536 bytes (64KB).
+            save_file (IO, optional):
+                A binary file-like object (opened in binary write mode) where filtered messages are saved.
+
+        Yields:
+            MarketMessage:
+                The next parsed MarketMessage object from the file.
+
+        Raises:
+            ValueError:
+                If a message does not start with the expected 0x00 byte, indicating
+                an unexpected file format or possible corruption.
+
+        Notes:
+            - Each message starts with a 0x00 byte.
+            - The following byte specifies the message length.
+            - The complete message consists of the first 2 bytes and 'message length' bytes of body.
+            - If a system message (message_type == b'S') with event_code == b'C' is encountered,
+                parsing stops immediately.
+
+        Example:
+            >>> data_file = "01302020.NASDAQ_ITCH50.gz"
+            >>> message_type = b"AFE" # Example message type to filter
+            >>> parser = MessageParser(message_type=message_type)
+            >>> with gzip.open(data_file, "rb") as itch_file:
+            >>> message_count = 0
+            >>> start_time = time.time()
+            >>> for message in parser.read_message_from_file(itch_file):
+            >>>     message_count += 1
+            >>>     if message_count <= 5:
+            >>>         print(message)
+            >>> end_time = time.time()
+            >>> print(f"Processed {message_count} messages in {end_time - start_time:.2f} seconds")
+            >>> print(f"Average time per message: {(end_time - start_time) / message_count:.6f} seconds")
+        """
+        if not file.readable():
+            raise ValueError("file must be opened in binary read mode")
+
+        if save_file is not None:
+            if not save_file.writable():
+                raise ValueError("save_file must be opened in binary write mode")
+
+        data_buffer = b""
+        offset = 0
+
+        while True:
+            if len(data_buffer) - offset < 2:
+                data_buffer = data_buffer[offset:]
+                offset = 0
+                new_data = file.read(cachesize)
+                if not new_data:
+                    break
+                data_buffer += new_data
+
+                if len(data_buffer) < 2:
+                    break
+
+            if data_buffer[offset : offset + 1] != b"\x00":
+                raise ValueError(
+                    "Unexpected byte: "
+                    + str(data_buffer[offset : offset + 1], encoding="ascii")
+                )
+
+            message_len = data_buffer[offset + 1]
+            total_len = 2 + message_len
+
+            if len(data_buffer) - offset < total_len:
+                data_buffer = data_buffer[offset:]
+                offset = 0
+
+                new_data = file.read(cachesize)
+                if not new_data:
+                    break
+                data_buffer += new_data
+                continue
+
+            message_data = data_buffer[offset + 2 : offset + total_len]
+            message = self.get_message_type(message_data)
+
+            if message.message_type in self.message_type:
+                if save_file is not None:
+                    msg_len_to_bytes = message.message_size.to_bytes()
+                    save_file.write(b"\x00" + msg_len_to_bytes + message.to_bytes())
+                yield message
+
+            if message.message_type == b"S":  # System message
+                if message.event_code == b"C":  # End of messages
+                    break
+            offset += total_len
+
+    def read_message_from_bytes(
+        self, data: bytes, save_file: IO = None
+    ) -> Iterator[MarketMessage]:
+        """
+        Process one or multiple ITCH binary messages from a raw bytes input.
+
+        Args:
+            data (bytes): Binary blob containing one or more ITCH messages.
+
+        save_file (IO, optional):
+            A binary file-like object (opened in binary write mode) where filtered messages are saved.
+
+        Yields:
+            MarketMessage:
+                The next parsed MarketMessage object from the bytes input.
+
+        Notes:
+            - Each message must be prefixed with a 0x00 header and a length byte.
+            - No buffering is done here — this is meant for real-time decoding.
+        """
+        if not isinstance(data, (bytes, bytearray)):
+            raise TypeError("data must be bytes or bytearray not " + str(type(data)))
+
+        if save_file is not None:
+            if not save_file.writable():
+                raise ValueError("save_file must be opened in binary write mode")
+
+        offset = 0
+        data_view = memoryview(data)
+        data_len = len(data_view)
+
+        while offset + 2 <= data_len:
+            if data_view[offset : offset + 1] != b"\x00":
+                raise ValueError(
+                    f"Unexpected start byte at offset {offset:offset+1}: "
+                    f"{data_view[offset : offset + 1].tobytes()}"
+                )
+            msg_len = data_view[offset + 1]
+            total_len = 2 + msg_len
+
+            if offset + total_len > data_len:
+                break
+
+            raw_msg = data_view[offset + 2 : offset + total_len]
+            message = self.get_message_type(raw_msg.tobytes())
+
+            if message.message_type in self.message_type:
+                if save_file is not None:
+                    msg_len_to_bytes = message.message_size.to_bytes()
+                    save_file.write(b"\x00" + msg_len_to_bytes + message.to_bytes())
+                yield message
+
+            if message.message_type == b"S":  # System message
+                if message.event_code == b"C":  # End of messages
+                    break
+
+            offset += total_len
+
+    def get_message_type(self, message: bytes) -> MarketMessage:
+        """
+        Take an entire bytearray and return the appropriate ITCH message
+        instance based on the message type indicator (first byte of the message).
+
+        All message type indicators are single ASCII characters.
+        """
+        message_type = message[0:1]
+        try:
+            return msgs[message_type](message)
+        except Exception:
+            raise ValueError(
+                f"Unknown message type: {message_type.decode(encoding='ascii')}"
+            )

{itchfeed-1.0.4 → itchfeed-1.0.5/itchfeed.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: itchfeed
-Version: 1.0.4
+Version: 1.0.5
 Summary: Simple parser for ITCH messages
 Home-page: https://github.com/bbalouki/itch
 Download-URL: https://pypi.org/project/itchfeed/
@@ -59,7 +59,7 @@ Dynamic: summary
 *   [Data Representation](#data-representation)
     *   [Common Attributes of `MarketMessage`](#common-attributes-of-marketmessage)
     *   [Common Methods of `MarketMessage`](#common-methods-of-marketmessage)
-    *   [Serializing Messages with `pack()`](#serializing-messages-with-pack)
+    *   [Serializing Messages with `to_bytes()`](#serializing-messages-with-to_bytes)
     *   [Data Types in Parsed Messages](#data-types-in-parsed-messages)
 *   [Error Handling](#error-handling)
     *   [Handling Strategies](#handling-strategies)
@@ -170,8 +170,8 @@ try:
 
 except FileNotFoundError:
     print(f"Error: File not found at {itch_file_path}")
-except Exception as e:
-    print(f"An error occurred: {e}")
+except ValueError as e:
+    print(f"An error occurred during parsing: {e}")
 
 ```
 
@@ -276,10 +276,10 @@ for message_type, sample_data in TEST_DATA.items():
     print(f"Creating message of type {message_type}")
     message = create_message(message_type, **sample_data)
     print(f"Created message: {message}")
-    print(f"Packed message: {message.pack()}")
+    print(f"Packed message: {message.to_bytes()}")
     print(f"Message size: {message.message_size}")
     print(f"Message Attributes: {message.get_attributes()}")
-    assert len(message.pack()) ==  message.message_size
+    assert len(message.to_bytes()) ==  message.message_size
     print()
 ```
 
@@ -388,14 +388,14 @@ The `MarketMessage` base class, and therefore all specific message classes, prov
     *   Returns a dictionary of all attributes (fields) of the message instance, along with their current values.
     *   This can be useful for generic inspection or logging of message contents without needing to know the specific type of the message beforehand.
 
-### Serializing Messages with `pack()`
+### Serializing Messages with `to_bytes()`
 
-Each specific message class (e.g., `SystemEventMessage`, `AddOrderNoMPIAttributionMessage`) also provides a `pack()` method. This method is the inverse of the parsing process.
+Each specific message class (e.g., `SystemEventMessage`, `AddOrderNoMPIAttributionMessage`) also provides a `to_bytes()` method. This method is the inverse of the parsing process.
 
 *   **Purpose:** It serializes the message object, with its current attribute values, back into its raw ITCH 5.0 binary format. The output is a `bytes` object representing the exact byte sequence that would appear in an ITCH data feed for that message.
 *   **Usefulness:**
     *   **Generating Test Data:** Create custom ITCH messages for testing your own ITCH processing applications.
-    *   **Modifying Messages:** Parse an existing message, modify some of its attributes, and then `pack()` it back into binary form.
+    *   **Modifying Messages:** Parse an existing message, modify some of its attributes, and then `to_bytes()` it back into binary form.
     *   **Creating Custom ITCH Feeds:** While more involved, you could use this to construct sequences of ITCH messages for specialized scenarios.
 
 **Example:**
@@ -415,21 +415,21 @@ import time
 #     for packing requires setting attributes manually if not using raw bytes for construction)
 
 event_msg = SystemEventMessage.__new__(SystemEventMessage) # Create instance without calling __init__
-event_msg.message_type = b'S' # Must be set for pack() to know its type
+event_msg.message_type = b'S' # Must be set for to_bytes() to know its type
 event_msg.stock_locate = 0 # Placeholder or actual value
 event_msg.tracking_number = 0 # Placeholder or actual value
 event_msg.event_code = b'O' # Example: Start of Messages
 
 # 2. Set the timestamp.
 #    The `timestamp` attribute (nanoseconds since midnight) must be set.
-#    The `pack()` method will internally use `split_timestamp()` to get the parts.
+#    The `to_bytes()` method will internally use `split_timestamp()` to get the parts.
 current_nanoseconds = int(time.time() * 1e9) % (24 * 60 * 60 * int(1e9))
 event_msg.timestamp = current_nanoseconds # Directly set the nanosecond timestamp
 
 # 3. Pack the message into binary format.
-#    The pack() method prepends the message type and then packs stock_locate,
+#    The to_bytes() method prepends the message type and then packs stock_locate,
 #    tracking_number, the split timestamp, and then the message-specific fields.
-packed_bytes = event_msg.pack()
+packed_bytes = event_msg.to_bytes()
 
 # 4. The result is a bytes object
 print(f"Packed {len(packed_bytes)} bytes: {packed_bytes.hex().upper()}")

{itchfeed-1.0.4 → itchfeed-1.0.5}/setup.py

@@ -12,7 +12,7 @@ with io.open(path.join(here, "README.md"), encoding="utf-8") as f:
 with io.open(path.join(here, "requirements.txt"), encoding="utf-8") as f:
     REQUIREMENTS = [line.rstrip() for line in f]
 
-VERSION = "1.0.4"
+VERSION = "1.0.5"
 DESCRIPTION = "Simple parser for ITCH messages"
 
 KEYWORDS = [

{itchfeed-1.0.4 → itchfeed-1.0.5}/tests/test_create_message.py

@@ -12,7 +12,7 @@ def test_create_message_and_pack(message_type, sample_data):
     created_message = create_message(message_type, **sample_data)
 
     # Pack the created message
-    packed_message = created_message.pack()
+    packed_message = created_message.to_bytes()
 
     # Unpack the message using the original class constructor
     message_class = messages[message_type]

{itchfeed-1.0.4 → itchfeed-1.0.5}/tests/test_messages.py

@@ -76,7 +76,7 @@ def pack_message_data(
 
     # Now call pack - instance should have all attributes defined in 'data'
     try:
-        packed_message = instance.pack()
+        packed_message = instance.to_bytes()
     except struct.error as e:
         print(f"Struct error during pack for {msg_class.__name__}: {e}")
         raise
@@ -183,8 +183,8 @@ def test_market_message_decode_price():
         msg.decode_price("stock")
 
     # Test trying to decode a method
-    with pytest.raises(ValueError, match="Please check the price attribute for pack"):
-        msg.decode_price("pack")
+    with pytest.raises(ValueError, match="Please check the price attribute for to_bytes"):
+        msg.decode_price("to_bytes")
 
 
 # Helper Function for Verifying Unpacked Attributes
@@ -385,7 +385,7 @@ def test_pack_unpack_decode_consistency(message_params):
     _verify_unpacked_attributes(instance, message_class, sample_data)
 
     # Step 3: Pack the initialized object and compare
-    repacked_message = instance.pack()
+    repacked_message = instance.to_bytes()
     assert repacked_message == expected_packed_message, (
         f"Repacked message does not match original for {message_class.__name__}"
     )
@@ -427,7 +427,7 @@ def test_get_attributes(message_params):
         assert "level1_price" in non_callable_attrs
 
     # Check some expected callable attributes
-    assert "pack" in callable_attrs
+    assert "to_bytes" in callable_attrs
     assert "decode" in callable_attrs
     assert "set_timestamp" in callable_attrs
     assert "split_timestamp" in callable_attrs

itchfeed-1.0.4/itch/parser.py

@@ -1,173 +0,0 @@
-from queue import Queue
-from typing import BinaryIO, List, Type
-
-from itch.messages import MESSAGES, MarketMessage
-from itch.messages import messages as msgs
-
-
-class MessageParser(object):
-    """
-    A market message parser for ITCH 5.0 data.
-
-    """
-
-    def __init__(self, message_type: bytes = MESSAGES):
-        self.message_type = message_type
-
-    def read_message_from_file(
-        self,
-        file: BinaryIO,
-        cachesize: int = 4096,
-    ) -> List[MarketMessage]:
-        """
-        Reads and parses market messages from a binary file-like object.
-
-        This method processes binary data in chunks, extracts individual messages
-        according to a specific format, and returns a list of successfully decoded 
-        MarketMessage objects. Parsing stops either when the end of the file is 
-        reached or when a system message with an end-of-messages event code is encountered.
-
-        Args:
-            file (BinaryIO): 
-                A binary file-like object (opened in binary mode) from which market messages are read.
-            cachesize (int, optional): 
-                The size (in bytes) of each data chunk read from the file. Defaults to 4096 bytes.
-
-        Returns:
-            List[MarketMessage]: 
-                A list of parsed MarketMessage objects that match the allowed message types 
-                defined in self.message_type.
-
-        Raises:
-            ValueError: 
-                If a message does not start with the expected 0x00 byte, indicating 
-                an unexpected file format or possible corruption.
-
-        Message Format:
-            - Each message starts with a 0x00 byte.
-            - The following byte specifies the message length.
-            - The complete message consists of the first 2 bytes and 'message length' bytes of body.
-            - If a system message (message_type == b'S') with event_code == b'C' is encountered, 
-            parsing stops immediately.
-
-        Example:
-            >>> with open('market_data.bin', 'rb') as binary_file:
-            >>>     messages = reader.read_message_from_file(binary_file, cachesize=4096)
-            >>>     for message in messages:
-            >>>         print(message)
-    """
-        max_message_size = 52
-        file_end_reached = False
-
-        data_buffer = file.read(cachesize)
-        buffer_len = len(data_buffer)
-        messages: List[MarketMessage] = []
-
-        while not file_end_reached:
-            if buffer_len < 2:
-                new_data = file.read(cachesize)
-                if not new_data:
-                    break
-                data_buffer += new_data
-                buffer_len = len(data_buffer)
-                continue
-
-            if data_buffer[0:1] != b"\x00":
-                raise ValueError(
-                    "Unexpected byte: " + str(data_buffer[0:1], encoding="ascii")
-                )
-
-            message_len = data_buffer[1]
-            total_len = 2 + message_len
-
-            if buffer_len < total_len:
-                # Wait for more data if message is incomplete
-                new_data = file.read(cachesize)
-                if not new_data:
-                    break
-                data_buffer += new_data
-                buffer_len = len(data_buffer)
-                continue
-            message_data = data_buffer[2:total_len]
-            message = self.get_message_type(message_data)
-
-            if message.message_type in self.message_type:
-                messages.append(message)
-
-            if message.message_type == b"S":  # System message
-                if message.event_code == b"C":  # End of messages
-                    break
-
-            # Update buffer
-            data_buffer = data_buffer[total_len:]
-            buffer_len = len(data_buffer)
-
-            if buffer_len < max_message_size and not file_end_reached:
-                new_data = file.read(cachesize)
-                if not new_data:
-                    file_end_reached = True
-                else:
-                    data_buffer += new_data
-                    buffer_len = len(data_buffer)
-
-        return messages
-
-    def read_message_from_bytes(self, data: bytes):
-        """
-        Process one or multiple ITCH binary messages from a raw bytes input.
-
-        Args:
-            data (bytes): Binary blob containing one or more ITCH messages.
-
-        Returns:
-            Queue: A queue containing parsed ITCH message objects.
-
-        Notes:
-            - Each message must be prefixed with a 0x00 header and a length byte.
-            - No buffering is done here — this is meant for real-time decoding.
-        """
-
-        offset = 0
-        messages = Queue()
-        while offset + 2 <= len(data):
-            # Each message starts with: 1-byte header (0x00) 1-byte length
-            if data[offset : offset + 1] != b"\x00":
-                raise ValueError(
-                    f"Unexpected start byte at offset {offset}: "
-                    f"{str(data[offset : offset + 1], encoding='ascii')}"
-                )
-
-            msg_len = data[offset + 1]
-            total_len = 2 + msg_len
-
-            if offset + total_len > len(data):
-                break
-
-            raw_msg = data[offset + 2 : offset + total_len]
-            message = self.get_message_type(raw_msg)
-
-            if message.message_type in self.message_type:
-                messages.put(message)
-
-            if message.message_type == b"S":  # System message
-                if message.event_code == b"C":  # End of messages
-                    break
-
-            offset += total_len
-
-        return messages
-
-    def get_message_type(self, message: bytes) -> Type[MarketMessage]:
-        """
-        Take an entire bytearray and return the appropriate ITCH message
-        instance based on the message type indicator (first byte of the message).
-
-        All message type indicators are single ASCII characters.
-        """
-        message_type = message[0:1]
-        try:
-            return msgs[message_type](message)
-        except Exception:
-            raise ValueError(
-                f"Unknown message type: {message_type.decode(encoding='ascii')}"
-            )