itchfeed 1.0.4__py3-none-any.whl → 1.0.6__py3-none-any.whl

itch/__init__.py

@@ -4,8 +4,14 @@ Nasdaq TotalView-ITCH 5.0 Parser
 
 __author__ = "Bertin Balouki SIMYELI"
 __copyright__ = "2025 Bertin Balouki SIMYELI"
-__email__ = "bertin@bbstrader.com"
+__email__ = "bertin@bbs-trading.com"
 __license__ = "MIT"
-__version__ = "1.0.4"
+
+from importlib.metadata import version, PackageNotFoundError
+
+try:
+    __version__ = version("itchfeed")
+except PackageNotFoundError:
+    __version__ = "unknown"
 
 

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: # type: ignore
         """
         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
 
@@ -90,9 +109,7 @@ class MarketMessage(object):
         ts1 = self.timestamp >> 32
         ts2 = self.timestamp - (ts1 << 32)
         return (ts1, ts2)
-        ts1 = self.timestamp >> 32
-        ts2 = self.timestamp - (ts1 << 32)
-        return (ts1, ts2)
+
 
     def decode_price(self, price_attr: str) -> float:
         precision = getattr(self, "price_precision")
@@ -166,7 +183,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 +305,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 +385,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 +446,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 +508,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 +559,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 +604,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 +665,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 +721,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 +786,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 +849,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 +903,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 +974,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 +1042,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 +1088,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 +1128,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 +1181,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 +1255,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 +1326,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 +1376,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 +1458,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 +1513,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 +1576,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 +1596,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 +1624,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.
 

itch/parser.py

@@ -1,5 +1,4 @@
-from queue import Queue
-from typing import BinaryIO, List, Type
+from typing import IO, BinaryIO, Callable, Iterator, Optional, Tuple
 
 from itch.messages import MESSAGES, MarketMessage
 from itch.messages import messages as msgs
@@ -14,160 +13,216 @@ class MessageParser(object):
     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]:
+    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)  # type: ignore
+        except Exception:
+            raise ValueError(
+                f"Unknown message type: {message_type.decode(encoding='ascii')}"
+            )
+
+    def _parse_message_from_buffer(
+        self, buffer: memoryview, offset: int
+    ) -> Optional[Tuple[MarketMessage, int]]:
+        """
+        Parses a single ITCH message from a memory buffer.
+
+        This method checks for a 2-byte header (a null byte and a length byte),
+        determines the full message size, and extracts the message if the
+        complete message is present in the buffer.
+
+        Args:
+            buffer (memoryview):
+                The buffer containing the binary data.
+            offset (int):
+                The starting position in the buffer to begin parsing.
+
+        Returns:
+            Optional[Tuple[MarketMessage, int]]:
+                A tuple containing the parsed MarketMessage and the total length
+                of the message including the header. Returns None if a complete
+                message could not be parsed.
+
+        Raises:
+            ValueError:
+                If the data at the current offset does not start with the
+                expected 0x00 byte.
+        """
+        buffer_len = len(buffer)
+        if offset + 2 > buffer_len:
+            return None
+
+        if buffer[offset : offset + 1] != b"\x00":
+            raise ValueError(
+                f"Unexpected start byte at offset {offset}: "
+                f"{buffer[offset : offset + 1].tobytes()}"
+            )
+
+        msg_len = buffer[offset + 1]
+        total_len = 2 + msg_len
+
+        if offset + total_len > buffer_len:
+            return None
+
+        raw_msg = buffer[offset + 2 : offset + total_len]
+        message = self.get_message_type(raw_msg.tobytes())
+        return message, total_len
+
+    def parse_file(
+        self, file: BinaryIO, cachesize: int = 65_536, save_file: Optional[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.parse_file(itch_file):
+            >>>     message_count += 1
+            >>>     if message_count <= 5:
             >>>         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
+            >>> 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 data_buffer[0:1] != b"\x00":
-                raise ValueError(
-                    "Unexpected byte: " + str(data_buffer[0:1], encoding="ascii")
-                )
+        if save_file is not None and not save_file.writable():
+            raise ValueError("save_file must be opened in binary write mode")
 
-            message_len = data_buffer[1]
-            total_len = 2 + message_len
+        data_buffer = b""
+        offset = 0
 
-            if buffer_len < total_len:
-                # Wait for more data if message is incomplete
+        while True:
+            parsed = self._parse_message_from_buffer(memoryview(data_buffer), offset)
+            if parsed is None:
+                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 = 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)
+            message, total_len = parsed
 
-            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)
+            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"
+                and getattr(message, "event_code", b"") == b"C"
+            ):
+                break
 
-        return messages
+            offset += total_len
 
-    def read_message_from_bytes(self, data: bytes):
+    def parse_stream(
+        self, data: bytes, save_file: Optional[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 and 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":
-                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):
+        data_view = memoryview(data)
+
+        while True:
+            parsed = self._parse_message_from_buffer(data_view, offset)
+            if parsed is None:
                 break
 
-            raw_msg = data[offset + 2 : offset + total_len]
-            message = self.get_message_type(raw_msg)
+            message, total_len = parsed
 
             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
+                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"
+                and getattr(message, "event_code", b"") == b"C"
+            ):
+                break
 
             offset += total_len
 
-        return messages
-
-    def get_message_type(self, message: bytes) -> Type[MarketMessage]:
+    def parse_messages(
+        self,
+        data: BinaryIO | bytes | bytearray,
+        callback: Callable[[MarketMessage], None],
+    ) -> None:
         """
-        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.
+        Parses messages from data and invokes a callback for each message.
         """
-        message_type = message[0:1]
-        try:
-            return msgs[message_type](message)
-        except Exception:
-            raise ValueError(
-                f"Unknown message type: {message_type.decode(encoding='ascii')}"
-            )
+        parser_func = (
+            self.parse_stream
+            if isinstance(data, (bytes, bytearray))
+            else self.parse_file
+        )
+        for message in parser_func(data):
+            callback(message)

{itchfeed-1.0.4.dist-info → itchfeed-1.0.6.dist-info}/METADATA

@@ -1,13 +1,12 @@
 Metadata-Version: 2.4
 Name: itchfeed
-Version: 1.0.4
+Version: 1.0.6
 Summary: Simple parser for ITCH messages
-Home-page: https://github.com/bbalouki/itch
-Download-URL: https://pypi.org/project/itchfeed/
-Author: Bertin Balouki SIMYELI
-Author-email: <bertin@bbstrader.com>
-Maintainer: Bertin Balouki SIMYELI
-License: The MIT License (MIT)
+Author-email: Bertin Balouki SIMYELI <bertin@bbs-trading.com>
+Maintainer-email: Bertin Balouki SIMYELI <bertin@bbs-trading.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/bbalouki/itch
+Project-URL: Download, https://pypi.org/project/itchfeed/
 Project-URL: Source Code, https://github.com/bbalouki/itch
 Keywords: Finance,Financial,Quantitative,Equities,Totalview-ITCH,Totalview,Nasdaq-ITCH,Nasdaq,ITCH,Data,Feed,ETFs,Funds,Trading,Investing
 Classifier: Development Status :: 5 - Production/Stable
@@ -19,20 +18,7 @@ Classifier: Operating System :: OS Independent
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pytest
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: download-url
-Dynamic: home-page
-Dynamic: keywords
-Dynamic: license
 Dynamic: license-file
-Dynamic: maintainer
-Dynamic: project-url
-Dynamic: requires-dist
-Dynamic: summary
 
 # Nasdaq TotalView-ITCH 5.0 Parser
 [![PYPI Version](https://img.shields.io/pypi/v/itchfeed)](https://pypi.org/project/itchfeed/)
@@ -59,7 +45,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)
@@ -111,6 +97,8 @@ After installation (typically via pip), import the necessary modules directly in
 
 ## Usage
 
+Download some sample data [here](https://emi.nasdaq.com/ITCH/Nasdaq%20ITCH/)
+
 ### Parsing from a Binary File
 
 This is useful for processing historical ITCH data stored in files. The `MessageParser` handles buffering efficiently.
@@ -131,9 +119,8 @@ parser = MessageParser() # Parses all messages by default
 
 # Path to your ITCH 5.0 data file
 itch_file_path = 'path/to/your/data'
-# you can find sample data [here](https://emi.nasdaq.com/ITCH/Nasdaq%20ITCH/)
 
-# The `read_message_from_file()` method reads the ITCH data in chunks.
+# The `parse_file()` method reads the ITCH data in chunks.
 # - `cachesize` (optional, default: 65536 bytes): This parameter determines the size of data chunks
 #   read from the file at a time. Adjusting this might impact performance for very large files
 #   or memory usage, but the default is generally suitable.
@@ -144,13 +131,9 @@ itch_file_path = 'path/to/your/data'
 
 try:
     with open(itch_file_path, 'rb') as itch_file:
-        # read_message_from_file returns a list of parsed message objects
-        parsed_messages = parser.read_message_from_file(itch_file) # You can also pass cachesize here, e.g., parser.read_message_from_file(itch_file, cachesize=131072)
-
-        print(f"Parsed {len(parsed_messages)} messages.")
-
+        # parse_file returns an Iterator of parsed message objects
         # Process the messages
-        for message in parsed_messages:
+        for message in parser.parse_file(itch_file):
             # Access attributes directly
             print(f"Type: {message.message_type.decode()}, Timestamp: {message.timestamp}")
 
@@ -170,8 +153,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}")
 
 ```
 
@@ -192,14 +175,8 @@ parser = MessageParser()
 # Example: \x00\x0bS...\x00\x25R...\x00\x27F...
 raw_binary_data: bytes = b"..." # Your raw ITCH 5.0 data chunk
 
-# read_message_from_bytes returns a queue of parsed message objects
-message_queue: Queue = parser.read_message_from_bytes(raw_binary_data)
-
-print(f"Parsed {message_queue.qsize()} messages from the byte chunk.")
-
-# Process messages from the queue
-while not message_queue.empty():
-    message = message_queue.get()
+# parse_stream returns an Iterator of parsed message objects
+for message in parser.parse_stream(raw_binary_data)
 
     print(f"Type: {message.message_type.decode()}, Timestamp: {message.timestamp}")
 
@@ -276,10 +253,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 +365,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 +392,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()}")
@@ -462,11 +439,12 @@ Common scenarios that can lead to a `ValueError` include:
 
 It's crucial to anticipate these errors in your application:
 
-*   **Use `try-except` Blocks:** Wrap your parsing calls (especially `read_message_from_file` or `read_message_from_bytes`) in `try-except ValueError as e:` blocks.
+*   **Use `try-except` Blocks:** Wrap your parsing calls (especially `parse_file` or `parse_stream`) in `try-except ValueError as e:` blocks.
     ```python
     try:
         # ... parsing operations ...
-        messages = parser.read_message_from_file(itch_file)
+        for message in parser.parse_file(itch_file):
+            ...
     except ValueError as e:
         print(f"An error occurred during parsing: {e}")
         # Log the error, problematic data chunk, or take other actions

itchfeed-1.0.6.dist-info/RECORD

@@ -0,0 +1,9 @@
+itch/__init__.py,sha256=ykG85u8WbMZnQt78wg-a4Zqm6dTGNf3lYRsqh5FOuPI,348
+itch/indicators.py,sha256=-Ed2M8I60xGQ1bIPZCGCKGb8ayT87JAnIaosfiBimXI,6542
+itch/messages.py,sha256=bXEcD9h0ZsD9IXVMfQa7FWZTpgiQoyeSdxZ9hrp3ukQ,64847
+itch/parser.py,sha256=1Skl8SBQz_SDqHEDkFHydJw0TEt3M_xNcUMAE19yquo,8442
+itchfeed-1.0.6.dist-info/licenses/LICENSE,sha256=f2u79rUzh-UcYH0RN0Ph0VvVYHBkYlVxtguhKmrHqsw,1089
+itchfeed-1.0.6.dist-info/METADATA,sha256=ZPgCxVsjBIAXxdkllrx57IrP-wE0oxkgafIZaSsxm0Q,33174
+itchfeed-1.0.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+itchfeed-1.0.6.dist-info/top_level.txt,sha256=xwsOYShvy3gc1rfyitCTgSxBZDGG1y6bfQxkdhIGmEM,5
+itchfeed-1.0.6.dist-info/RECORD,,

itchfeed-1.0.4.dist-info/RECORD

@@ -1,9 +0,0 @@
-itch/__init__.py,sha256=M9Jirj4-XXdaCoTcU2_g89z7JHK8mDtJflTFf9HnU-k,205
-itch/indicators.py,sha256=-Ed2M8I60xGQ1bIPZCGCKGb8ayT87JAnIaosfiBimXI,6542
-itch/messages.py,sha256=lm5pKQ00ETMbTij9HqaYVrN08JJdQe-mZKB_C7IAetU,63934
-itch/parser.py,sha256=BOrkGsmRkcYnXSf5S9yqrwzP0jqtkH5mGCpWCeiWNTg,6155
-itchfeed-1.0.4.dist-info/licenses/LICENSE,sha256=f2u79rUzh-UcYH0RN0Ph0VvVYHBkYlVxtguhKmrHqsw,1089
-itchfeed-1.0.4.dist-info/METADATA,sha256=HYjteeevesrGUcrjvuNlW2P-0B9k8jtL0qdovoaLZT0,33793
-itchfeed-1.0.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-itchfeed-1.0.4.dist-info/top_level.txt,sha256=xwsOYShvy3gc1rfyitCTgSxBZDGG1y6bfQxkdhIGmEM,5
-itchfeed-1.0.4.dist-info/RECORD,,