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

itch/messages.py

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

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.4.dist-info → itchfeed-1.0.5.dist-info}/METADATA

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

itchfeed-1.0.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.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,,