itchfeed 1.0.3__tar.gz → 1.0.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: itchfeed
-Version: 1.0.3
+Version: 1.0.5
 Summary: Simple parser for ITCH messages
 Home-page: https://github.com/bbalouki/itch
 Download-URL: https://pypi.org/project/itchfeed/
@@ -52,12 +52,14 @@ Dynamic: summary
 *   [Usage](#usage)
     *   [Parsing from a Binary File](#parsing-from-a-binary-file)
     *   [Parsing from Raw Bytes](#parsing-from-raw-bytes)
+    *   [Creating Messages Programmatically](#creating-messages-programmatically)
+    *   [Example with Real-World Sample Data](#example-with-real-world-sample-data)
 *   [Interpreting Market Data (Conceptual Overview)](#interpreting-market-data-conceptual-overview)
 *   [Supported Message Types](#supported-message-types)
 *   [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)
@@ -168,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}")
 
 ```
 
@@ -211,6 +213,78 @@ while not message_queue.empty():
 
 ```
 
+### Creating Messages Programmatically
+
+In addition to parsing, `itch` provides a simple way to create ITCH message objects from scratch. This is particularly useful for:
+- **Testing:** Generating specific message sequences to test your own downstream applications.
+- **Simulation:** Building custom market simulators that produce ITCH-compliant data streams.
+- **Data Generation:** Creating custom datasets for analysis or backtesting.
+
+The `create_message` function is the primary tool for this purpose. It takes a `message_type` and keyword arguments corresponding to the desired message attributes.
+
+Here's a basic example of how to create a `SystemEventMessage` to signal the "Start of Messages":
+
+```python
+from itch.messages import create_message, SystemEventMessage
+
+# Define the attributes for the message
+event_attributes = {
+    "stock_locate": 1,
+    "tracking_number": 2,
+    "timestamp": 1651500000 * 1_000_000_000,
+    "event_code": b"O"
+}
+
+# Create the message object
+system_event_message = create_message(b"S", **event_attributes)
+
+# You can now work with this object just like one from the parser
+print(isinstance(system_event_message, SystemEventMessage))
+# Expected output: True
+
+print(system_event_message)
+# Expected output: SystemEventMessage(description='System Event Message', event_code='O', message_format='!HHHIc', message_pack_format='!cHHHIc', message_size=12, message_type='S', price_precision=4, stock_locate=1, timestamp=86311638581248, tracking_number=2)
+```
+
+### Example with Real-World Sample Data
+
+You can also use the sample data provided in `tests/data.py` to create messages, simulating a more realistic scenario.
+
+```python
+from itch.messages import create_message, AddOrderNoMPIAttributionMessage
+from tests.data import TEST_DATA
+
+# Get the sample data for an "Add Order" message (type 'A')
+add_order_data = TEST_DATA[b"A"]
+
+# Create the message
+add_order_message = create_message(b"A", **add_order_data)
+
+# Verify the type
+print(isinstance(add_order_message, AddOrderNoMPIAttributionMessage))
+# Expected output: True
+
+# Access its attributes
+print(f"Stock: {add_order_message.stock.decode().strip()}")
+# Expected output: Stock: AAPL
+
+print(f"Price: {add_order_message.decode_price('price')}")
+# Expected output: Price: 150.1234
+
+# Test all message types in the sample data
+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.to_bytes()}")
+    print(f"Message size: {message.message_size}")
+    print(f"Message Attributes: {message.get_attributes()}")
+    assert len(message.to_bytes()) ==  message.message_size
+    print()
+```
+
+By leveraging `create_message`, you can build robust test suites for your trading algorithms, compliance checks, or data analysis pipelines without needing a live data feed.
+
 ## Interpreting Market Data (Conceptual Overview)
 
 Parsing individual ITCH messages is the first step; understanding market dynamics often requires processing and correlating a sequence of these messages. This library provides the tools to decode messages, but interpreting their collective meaning requires building further logic.
@@ -314,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:**
@@ -341,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.3 → itchfeed-1.0.5}/README.md

@@ -16,12 +16,14 @@
 *   [Usage](#usage)
     *   [Parsing from a Binary File](#parsing-from-a-binary-file)
     *   [Parsing from Raw Bytes](#parsing-from-raw-bytes)
+    *   [Creating Messages Programmatically](#creating-messages-programmatically)
+    *   [Example with Real-World Sample Data](#example-with-real-world-sample-data)
 *   [Interpreting Market Data (Conceptual Overview)](#interpreting-market-data-conceptual-overview)
 *   [Supported Message Types](#supported-message-types)
 *   [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)
@@ -132,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}")
 
 ```
 
@@ -175,6 +177,78 @@ while not message_queue.empty():
 
 ```
 
+### Creating Messages Programmatically
+
+In addition to parsing, `itch` provides a simple way to create ITCH message objects from scratch. This is particularly useful for:
+- **Testing:** Generating specific message sequences to test your own downstream applications.
+- **Simulation:** Building custom market simulators that produce ITCH-compliant data streams.
+- **Data Generation:** Creating custom datasets for analysis or backtesting.
+
+The `create_message` function is the primary tool for this purpose. It takes a `message_type` and keyword arguments corresponding to the desired message attributes.
+
+Here's a basic example of how to create a `SystemEventMessage` to signal the "Start of Messages":
+
+```python
+from itch.messages import create_message, SystemEventMessage
+
+# Define the attributes for the message
+event_attributes = {
+    "stock_locate": 1,
+    "tracking_number": 2,
+    "timestamp": 1651500000 * 1_000_000_000,
+    "event_code": b"O"
+}
+
+# Create the message object
+system_event_message = create_message(b"S", **event_attributes)
+
+# You can now work with this object just like one from the parser
+print(isinstance(system_event_message, SystemEventMessage))
+# Expected output: True
+
+print(system_event_message)
+# Expected output: SystemEventMessage(description='System Event Message', event_code='O', message_format='!HHHIc', message_pack_format='!cHHHIc', message_size=12, message_type='S', price_precision=4, stock_locate=1, timestamp=86311638581248, tracking_number=2)
+```
+
+### Example with Real-World Sample Data
+
+You can also use the sample data provided in `tests/data.py` to create messages, simulating a more realistic scenario.
+
+```python
+from itch.messages import create_message, AddOrderNoMPIAttributionMessage
+from tests.data import TEST_DATA
+
+# Get the sample data for an "Add Order" message (type 'A')
+add_order_data = TEST_DATA[b"A"]
+
+# Create the message
+add_order_message = create_message(b"A", **add_order_data)
+
+# Verify the type
+print(isinstance(add_order_message, AddOrderNoMPIAttributionMessage))
+# Expected output: True
+
+# Access its attributes
+print(f"Stock: {add_order_message.stock.decode().strip()}")
+# Expected output: Stock: AAPL
+
+print(f"Price: {add_order_message.decode_price('price')}")
+# Expected output: Price: 150.1234
+
+# Test all message types in the sample data
+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.to_bytes()}")
+    print(f"Message size: {message.message_size}")
+    print(f"Message Attributes: {message.get_attributes()}")
+    assert len(message.to_bytes()) ==  message.message_size
+    print()
+```
+
+By leveraging `create_message`, you can build robust test suites for your trading algorithms, compliance checks, or data analysis pipelines without needing a live data feed.
+
 ## Interpreting Market Data (Conceptual Overview)
 
 Parsing individual ITCH messages is the first step; understanding market dynamics often requires processing and correlating a sequence of these messages. This library provides the tools to decode messages, but interpreting their collective meaning requires building further logic.
@@ -278,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:**
@@ -305,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.3 → itchfeed-1.0.5}/itch/__init__.py

@@ -6,5 +6,6 @@ __author__ = "Bertin Balouki SIMYELI"
 __copyright__ = "2025 Bertin Balouki SIMYELI"
 __email__ = "bertin@bbstrader.com"
 __license__ = "MIT"
-__version__ = "1.0.0"
+__version__ = "1.0.4"
+
 

{itchfeed-1.0.3 → 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,9 +40,27 @@ class MarketMessage(object):
     tracking_number: int
     price_precision: int = 4
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return repr(self.decode())
 
+    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
+
     def set_timestamp(self, ts1: int, ts2: int):
         """
         Reconstructs a 6-byte timestamp (48 bits) from two 32-bit unsigned integers.
@@ -159,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,
@@ -281,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,
@@ -361,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,
@@ -422,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,
@@ -484,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,
@@ -535,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,
@@ -580,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,
@@ -641,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,
@@ -697,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,
@@ -762,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,
@@ -825,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,
@@ -879,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,
@@ -950,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,
@@ -1018,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,
@@ -1064,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,
@@ -1104,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,
@@ -1157,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,
@@ -1231,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,
@@ -1302,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,
@@ -1352,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,
@@ -1434,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,
@@ -1489,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,
@@ -1552,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,
@@ -1572,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,
@@ -1598,3 +1624,51 @@ messages: Dict[bytes, Type[MarketMessage]] = {
     b"N": RetailPriceImprovementIndicator,
     b"O": DLCRMessage,
 }
+
+
+def create_message(message_type: bytes, **kwargs) -> MarketMessage:
+    """
+    Creates a new message of a given type with specified attributes.
+
+    This function simplifies the process of message creation by handling
+    the instantiation and attribute setting for any valid message type.
+    It's particularly useful for simulating trading environments or
+    generating test data without manually packing and unpacking bytes.
+
+    Args:
+        message_type (bytes):
+            A single-byte identifier for the message type (e.g., b'A'
+            for AddOrderNoMPIAttributionMessage).
+        **kwargs:
+            Keyword arguments representing the attributes of the message.
+            These must match the attributes expected by the message class
+            (e.g., `stock_locate`, `timestamp`, `price`).
+
+    Returns:
+        MarketMessage:
+            An instance of the corresponding message class, populated with
+            the provided attributes.
+
+    Raises:
+        ValueError:
+            If the `message_type` is not found in the registered messages.
+    """
+    message_class = messages.get(message_type)
+    if not message_class:
+        raise ValueError(f"Unknown message type: {message_type.decode()}")
+
+    # Create a new instance without calling __init__
+    # __init__ is for unpacking, not creating
+    instance = message_class.__new__(message_class)
+
+    # Set attributes from kwargs
+    for key, value in kwargs.items():
+        if key == 'timestamp':
+            # Timestamps are 48-bit, so we need to mask the original value
+            value &= ((1 << 48) - 1)
+        setattr(instance, key, value)
+
+    # Set the message_type attribute on the instance, as it's used by pack()
+    instance.message_type = message_type
+
+    return instance

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.3 → itchfeed-1.0.5/itchfeed.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: itchfeed
-Version: 1.0.3
+Version: 1.0.5
 Summary: Simple parser for ITCH messages
 Home-page: https://github.com/bbalouki/itch
 Download-URL: https://pypi.org/project/itchfeed/
@@ -52,12 +52,14 @@ Dynamic: summary
 *   [Usage](#usage)
     *   [Parsing from a Binary File](#parsing-from-a-binary-file)
     *   [Parsing from Raw Bytes](#parsing-from-raw-bytes)
+    *   [Creating Messages Programmatically](#creating-messages-programmatically)
+    *   [Example with Real-World Sample Data](#example-with-real-world-sample-data)
 *   [Interpreting Market Data (Conceptual Overview)](#interpreting-market-data-conceptual-overview)
 *   [Supported Message Types](#supported-message-types)
 *   [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)
@@ -168,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}")
 
 ```
 
@@ -211,6 +213,78 @@ while not message_queue.empty():
 
 ```
 
+### Creating Messages Programmatically
+
+In addition to parsing, `itch` provides a simple way to create ITCH message objects from scratch. This is particularly useful for:
+- **Testing:** Generating specific message sequences to test your own downstream applications.
+- **Simulation:** Building custom market simulators that produce ITCH-compliant data streams.
+- **Data Generation:** Creating custom datasets for analysis or backtesting.
+
+The `create_message` function is the primary tool for this purpose. It takes a `message_type` and keyword arguments corresponding to the desired message attributes.
+
+Here's a basic example of how to create a `SystemEventMessage` to signal the "Start of Messages":
+
+```python
+from itch.messages import create_message, SystemEventMessage
+
+# Define the attributes for the message
+event_attributes = {
+    "stock_locate": 1,
+    "tracking_number": 2,
+    "timestamp": 1651500000 * 1_000_000_000,
+    "event_code": b"O"
+}
+
+# Create the message object
+system_event_message = create_message(b"S", **event_attributes)
+
+# You can now work with this object just like one from the parser
+print(isinstance(system_event_message, SystemEventMessage))
+# Expected output: True
+
+print(system_event_message)
+# Expected output: SystemEventMessage(description='System Event Message', event_code='O', message_format='!HHHIc', message_pack_format='!cHHHIc', message_size=12, message_type='S', price_precision=4, stock_locate=1, timestamp=86311638581248, tracking_number=2)
+```
+
+### Example with Real-World Sample Data
+
+You can also use the sample data provided in `tests/data.py` to create messages, simulating a more realistic scenario.
+
+```python
+from itch.messages import create_message, AddOrderNoMPIAttributionMessage
+from tests.data import TEST_DATA
+
+# Get the sample data for an "Add Order" message (type 'A')
+add_order_data = TEST_DATA[b"A"]
+
+# Create the message
+add_order_message = create_message(b"A", **add_order_data)
+
+# Verify the type
+print(isinstance(add_order_message, AddOrderNoMPIAttributionMessage))
+# Expected output: True
+
+# Access its attributes
+print(f"Stock: {add_order_message.stock.decode().strip()}")
+# Expected output: Stock: AAPL
+
+print(f"Price: {add_order_message.decode_price('price')}")
+# Expected output: Price: 150.1234
+
+# Test all message types in the sample data
+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.to_bytes()}")
+    print(f"Message size: {message.message_size}")
+    print(f"Message Attributes: {message.get_attributes()}")
+    assert len(message.to_bytes()) ==  message.message_size
+    print()
+```
+
+By leveraging `create_message`, you can build robust test suites for your trading algorithms, compliance checks, or data analysis pipelines without needing a live data feed.
+
 ## Interpreting Market Data (Conceptual Overview)
 
 Parsing individual ITCH messages is the first step; understanding market dynamics often requires processing and correlating a sequence of these messages. This library provides the tools to decode messages, but interpreting their collective meaning requires building further logic.
@@ -314,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:**
@@ -341,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.3 → itchfeed-1.0.5}/itchfeed.egg-info/SOURCES.txt

@@ -12,4 +12,5 @@ itchfeed.egg-info/SOURCES.txt
 itchfeed.egg-info/dependency_links.txt
 itchfeed.egg-info/requires.txt
 itchfeed.egg-info/top_level.txt
+tests/test_create_message.py
 tests/test_messages.py

{itchfeed-1.0.3 → 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.3"
+VERSION = "1.0.5"
 DESCRIPTION = "Simple parser for ITCH messages"
 
 KEYWORDS = [

itchfeed-1.0.5/tests/test_create_message.py

@@ -0,0 +1,28 @@
+import pytest
+from itch.messages import create_message, messages
+from .data import TEST_DATA
+
+@pytest.mark.parametrize("message_type, sample_data", TEST_DATA.items())
+def test_create_message_and_pack(message_type, sample_data):
+    """
+    Tests that create_message correctly creates a message that can be packed,
+    and that the packed message can be unpacked to match the original data.
+    """
+    # Create a message using the new function
+    created_message = create_message(message_type, **sample_data)
+
+    # Pack the created message
+    packed_message = created_message.to_bytes()
+
+    # Unpack the message using the original class constructor
+    message_class = messages[message_type]
+    unpacked_message = message_class(packed_message)
+
+    # Verify that the attributes of the unpacked message match the original data
+    for key, expected_value in sample_data.items():
+        if key == 'timestamp':
+            # Timestamps are 48-bit, so we need to mask the original value
+            expected_value &= ((1 << 48) - 1)
+        assert getattr(unpacked_message, key) == expected_value, (
+            f"Attribute '{key}' mismatch for message type {message_type.decode()}"
+        )

{itchfeed-1.0.3 → 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.3/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')}"
-            )