itchfeed 1.0.3__py3-none-any.whl → 1.0.5__py3-none-any.whl

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"
+
 

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

itch/parser.py

@@ -1,5 +1,4 @@
-from queue import Queue
-from typing import BinaryIO, List, Type
+from typing import IO, BinaryIO, Iterator
 
 from itch.messages import MESSAGES, MarketMessage
 from itch.messages import messages as msgs
@@ -15,139 +14,161 @@ class MessageParser(object):
         self.message_type = message_type
 
     def read_message_from_file(
-        self,
-        file: BinaryIO,
-        cachesize: int = 4096,
-    ) -> List[MarketMessage]:
+        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 
+        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): 
+            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.
+            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.
 
-        Returns:
-            List[MarketMessage]: 
-                A list of parsed MarketMessage objects that match the allowed message types 
-                defined in self.message_type.
+        Yields:
+            MarketMessage:
+                The next parsed MarketMessage object from the file.
 
         Raises:
-            ValueError: 
-                If a message does not start with the expected 0x00 byte, indicating 
+            ValueError:
+                If a message does not start with the expected 0x00 byte, indicating
                 an unexpected file format or possible corruption.
 
-        Message Format:
+        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.
+            - 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:
+            >>> 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)
-    """
-        max_message_size = 52
-        file_end_reached = False
+            >>> 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")
 
-        data_buffer = file.read(cachesize)
-        buffer_len = len(data_buffer)
-        messages: List[MarketMessage] = []
+        if save_file is not None:
+            if not save_file.writable():
+                raise ValueError("save_file must be opened in binary write mode")
 
-        while not file_end_reached:
-            if buffer_len < 2:
+        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
-                buffer_len = len(data_buffer)
-                continue
 
-            if data_buffer[0:1] != b"\x00":
+                if len(data_buffer) < 2:
+                    break
+
+            if data_buffer[offset : offset + 1] != b"\x00":
                 raise ValueError(
-                    "Unexpected byte: " + str(data_buffer[0:1], encoding="ascii")
+                    "Unexpected byte: "
+                    + str(data_buffer[offset : offset + 1], encoding="ascii")
                 )
 
-            message_len = data_buffer[1]
+            message_len = data_buffer[offset + 1]
             total_len = 2 + message_len
 
-            if buffer_len < total_len:
-                # Wait for more data if message is incomplete
+            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
-                buffer_len = len(data_buffer)
                 continue
-            message_data = data_buffer[2:total_len]
+
+            message_data = data_buffer[offset + 2 : offset + total_len]
             message = self.get_message_type(message_data)
 
             if message.message_type in self.message_type:
-                messages.append(message)
+                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
 
-            # 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):
+    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.
 
-        Returns:
-            Queue: A queue containing parsed ITCH message objects.
+        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
-        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":
+        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}: "
-                    f"{str(data[offset : offset + 1], encoding='ascii')}"
+                    f"Unexpected start byte at offset {offset:offset+1}: "
+                    f"{data_view[offset : offset + 1].tobytes()}"
                 )
-
-            msg_len = data[offset + 1]
+            msg_len = data_view[offset + 1]
             total_len = 2 + msg_len
 
-            if offset + total_len > len(data):
+            if offset + total_len > data_len:
                 break
 
-            raw_msg = data[offset + 2 : offset + total_len]
-            message = self.get_message_type(raw_msg)
+            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:
-                messages.put(message)
+                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
@@ -155,9 +176,7 @@ class MessageParser(object):
 
             offset += total_len
 
-        return messages
-
-    def get_message_type(self, message: bytes) -> Type[MarketMessage]:
+    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).

{itchfeed-1.0.3.dist-info → itchfeed-1.0.5.dist-info}/METADATA

@@ -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.5.dist-info/RECORD

@@ -0,0 +1,9 @@
+itch/__init__.py,sha256=M9Jirj4-XXdaCoTcU2_g89z7JHK8mDtJflTFf9HnU-k,205
+itch/indicators.py,sha256=-Ed2M8I60xGQ1bIPZCGCKGb8ayT87JAnIaosfiBimXI,6542
+itch/messages.py,sha256=UWhpFzgfaDwAah-R0p24LtpP7-G5pP1jnOMakBc33t4,64935
+itch/parser.py,sha256=glYjyeqY9841UqcOD8Wck-Az70AUwQxTt9SckYoxOg0,7422
+itchfeed-1.0.5.dist-info/licenses/LICENSE,sha256=f2u79rUzh-UcYH0RN0Ph0VvVYHBkYlVxtguhKmrHqsw,1089
+itchfeed-1.0.5.dist-info/METADATA,sha256=gUXQ25Q5Cvw6EHGVLUDuTXFOTdUSp8VQEIyKUOd8LU8,33853
+itchfeed-1.0.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+itchfeed-1.0.5.dist-info/top_level.txt,sha256=xwsOYShvy3gc1rfyitCTgSxBZDGG1y6bfQxkdhIGmEM,5
+itchfeed-1.0.5.dist-info/RECORD,,

itchfeed-1.0.3.dist-info/RECORD

@@ -1,9 +0,0 @@
-itch/__init__.py,sha256=m8ulOH0nET4yLoKcqWJA-VjOEZldGo932t95rHOZh4w,204
-itch/indicators.py,sha256=-Ed2M8I60xGQ1bIPZCGCKGb8ayT87JAnIaosfiBimXI,6542
-itch/messages.py,sha256=UHr4eBTtgiLg9vO53GpciAxiAO9AD9uCu8Xz3WnfadM,61927
-itch/parser.py,sha256=BOrkGsmRkcYnXSf5S9yqrwzP0jqtkH5mGCpWCeiWNTg,6155
-itchfeed-1.0.3.dist-info/licenses/LICENSE,sha256=f2u79rUzh-UcYH0RN0Ph0VvVYHBkYlVxtguhKmrHqsw,1089
-itchfeed-1.0.3.dist-info/METADATA,sha256=nfZbTBXUq5Ghq1xhls4fttblPNlpRGtqZth1h8lnx-4,30699
-itchfeed-1.0.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-itchfeed-1.0.3.dist-info/top_level.txt,sha256=xwsOYShvy3gc1rfyitCTgSxBZDGG1y6bfQxkdhIGmEM,5
-itchfeed-1.0.3.dist-info/RECORD,,