moose-lib 0.4.160__py3-none-any.whl → 0.4.162__py3-none-any.whl

moose_lib/data_models.py

@@ -2,6 +2,7 @@ import dataclasses
 from decimal import Decimal
 import re
 from enum import Enum
+from inspect import isclass
 from uuid import UUID
 from datetime import datetime, date
 
@@ -162,6 +163,11 @@ def py_type_to_column_type(t: type, mds: list[Any]) -> Tuple[bool, list[Any], Da
         data_type = "UUID"
     elif t is Any:
         data_type = "Json"
+    elif get_origin(t) is Literal and all(isinstance(arg, str) for arg in get_args(t)):
+        data_type = "String"
+        mds.append("LowCardinality")
+    elif not isclass(t):
+        raise ValueError(f"Unknown type {t}")
     elif issubclass(t, BaseModel):
         data_type = Nested(
             name=t.__name__,
@@ -186,15 +192,15 @@ def _to_columns(model: type[BaseModel]) -> list[Column]:
         primary_key, field_type = handle_key(field_type)
         is_jwt, field_type = handle_jwt(field_type)
 
-        optional, md, data_type = py_type_to_column_type(field_type, field_info.metadata)
+        optional, mds, data_type = py_type_to_column_type(field_type, field_info.metadata)
 
         annotations = []
-        for m in md:
-            if isinstance(m, AggregateFunction):
+        for md in mds:
+            if isinstance(md, AggregateFunction):
                 annotations.append(
-                    ("aggregationFunction", m.to_dict())
+                    ("aggregationFunction", md.to_dict())
                 )
-            if m == "LowCardinality":
+            if md == "LowCardinality":
                 annotations.append(
                     ("LowCardinality", True)
                 )

moose_lib/dmv2.py

@@ -9,8 +9,10 @@ It mirrors the functionality of the TypeScript `dmv2` module, enabling the defin
 of data infrastructure using Python and Pydantic models.
 """
 import dataclasses
-from typing import Any, Generic, Optional, TypeVar, Callable, Union
-from pydantic import BaseModel, ConfigDict
+import datetime
+from typing import Any, Generic, Optional, TypeVar, Callable, Union, Literal
+from pydantic import BaseModel, ConfigDict, AliasGenerator
+from pydantic.alias_generators import to_camel
 from pydantic.fields import FieldInfo
 from pydantic.json_schema import JsonSchemaValue
 
@@ -176,6 +178,8 @@ class TransformConfig(BaseModel):
                  Allows multiple transformations to the same destination if versions differ.
     """
     version: Optional[str] = None
+    dead_letter_queue: "Optional[DeadLetterQueue]" = None
+    model_config = ConfigDict(arbitrary_types_allowed=True)
 
 
 class ConsumerConfig(BaseModel):
@@ -186,6 +190,8 @@ class ConsumerConfig(BaseModel):
                  Allows multiple consumers if versions differ.
     """
     version: Optional[str] = None
+    dead_letter_queue: "Optional[DeadLetterQueue]" = None
+    model_config = ConfigDict(arbitrary_types_allowed=True)
 
 
 @dataclasses.dataclass
@@ -242,7 +248,8 @@ class Stream(TypedMooseResource, Generic[T]):
         self.transformations = {}
         _streams[name] = self
 
-    def add_transform(self, destination: "Stream[U]", transformation: Callable[[T], ZeroOrMany[U]], config: TransformConfig = TransformConfig()):
+    def add_transform(self, destination: "Stream[U]", transformation: Callable[[T], ZeroOrMany[U]],
+                      config: TransformConfig = None):
         """Adds a transformation step from this stream to a destination stream.
 
         The transformation function receives a record of type `T` and should return
@@ -253,16 +260,19 @@ class Stream(TypedMooseResource, Generic[T]):
             transformation: A callable that performs the transformation.
             config: Optional configuration, primarily for setting a version.
         """
+        config = config or TransformConfig()
         if destination.name in self.transformations:
             existing_transforms = self.transformations[destination.name]
             # Check if a transform with this version already exists
             has_version = any(t.config.version == config.version for t in existing_transforms)
             if not has_version:
-                existing_transforms.append(TransformEntry(destination=destination, transformation=transformation, config=config))
+                existing_transforms.append(
+                    TransformEntry(destination=destination, transformation=transformation, config=config))
         else:
-            self.transformations[destination.name] = [TransformEntry(destination=destination, transformation=transformation, config=config)]
+            self.transformations[destination.name] = [
+                TransformEntry(destination=destination, transformation=transformation, config=config)]
 
-    def add_consumer(self, consumer: Callable[[T], None], config: ConsumerConfig = ConsumerConfig()):
+    def add_consumer(self, consumer: Callable[[T], None], config: ConsumerConfig = None):
         """Adds a consumer function to be executed for each record in the stream.
 
         Consumers are typically used for side effects like logging or triggering external actions.
@@ -271,6 +281,7 @@ class Stream(TypedMooseResource, Generic[T]):
             consumer: A callable that accepts a record of type `T`.
             config: Optional configuration, primarily for setting a version.
         """
+        config = config or ConsumerConfig()
         has_version = any(c.config.version == config.version for c in self.consumers)
         if not has_version:
             self.consumers.append(ConsumerEntry(consumer=consumer, config=config))
@@ -321,6 +332,68 @@ class Stream(TypedMooseResource, Generic[T]):
         self._multipleTransformations = transformation
 
 
+class DeadLetterModel(BaseModel, Generic[T]):
+    model_config = ConfigDict(alias_generator=AliasGenerator(
+        serialization_alias=to_camel,
+    ))
+    original_record: Any
+    error_message: str
+    error_type: str
+    failed_at: datetime.datetime
+    source: Literal["api", "transform", "table"]
+
+    def as_t(self) -> T:
+        return self._t.model_validate(self.original_record)
+
+
+class DeadLetterQueue(Stream, Generic[T]):
+    """A specialized Stream for handling failed records.
+    
+    Dead letter queues store records that failed during processing, along with
+    error information to help diagnose and potentially recover from failures.
+    
+    Attributes:
+        All attributes inherited from Stream.
+    """
+
+    _model_type: type[T]
+
+    def __init__(self, name: str, config: StreamConfig = StreamConfig(), **kwargs):
+        """Initialize a new DeadLetterQueue.
+        
+        Args:
+            name: The name of the dead letter queue stream.
+            config: Configuration for the stream.
+        """
+        self._model_type = self._get_type(kwargs)
+        kwargs["t"] = DeadLetterModel[self._model_type]
+        super().__init__(name, config, **kwargs)
+
+    def add_transform(self, destination: Stream[U], transformation: Callable[[DeadLetterModel[T]], ZeroOrMany[U]],
+                      config: TransformConfig = None):
+        def wrapped_transform(record: DeadLetterModel[T]):
+            record._t = self._model_type
+            return transformation(record)
+
+        config = config or TransformConfig()
+        super().add_transform(destination, wrapped_transform, config)
+
+    def add_consumer(self, consumer: Callable[[DeadLetterModel[T]], None], config: ConsumerConfig = None):
+        def wrapped_consumer(record: DeadLetterModel[T]):
+            record._t = self._model_type
+            return consumer(record)
+
+        config = config or ConsumerConfig()
+        super().add_consumer(wrapped_consumer, config)
+
+    def set_multi_transform(self, transformation: Callable[[DeadLetterModel[T]], list[_RoutedMessage]]):
+        def wrapped_transform(record: DeadLetterModel[T]):
+            record._t = self._model_type
+            return transformation(record)
+
+        super().set_multi_transform(wrapped_transform)
+
+
 class IngestConfig(BaseModel):
     """Basic configuration for an ingestion point.
 
@@ -602,10 +675,10 @@ class SqlResource:
     pushes_data_to: list[Union[OlapTable, "SqlResource"]]
 
     def __init__(
-        self, 
-        name: str, 
-        setup: list[str], 
-        teardown: list[str], 
+        self,
+        name: str,
+        setup: list[str],
+        teardown: list[str],
         pulls_data_from: Optional[list[Union[OlapTable, "SqlResource"]]] = None,
         pushes_data_to: Optional[list[Union[OlapTable, "SqlResource"]]] = None
     ):
@@ -705,12 +778,12 @@ class MaterializedView(SqlResource, BaseTypedResource, Generic[T]):
         )
 
         super().__init__(
-            options.materialized_view_name, 
-            setup, 
+            options.materialized_view_name,
+            setup,
             teardown,
             pulls_data_from=options.select_tables,
             pushes_data_to=[target_table]
         )
-        
+
         self.target_table = target_table
         self.config = options

moose_lib/streaming/streaming_function_runner.py

@@ -15,6 +15,7 @@ The runner handles:
 
 import argparse
 import dataclasses
+import traceback
 from datetime import datetime, timezone
 from importlib import import_module
 import io
@@ -27,8 +28,8 @@ import threading
 import time
 from typing import Optional, Callable, Tuple, Any
 
-from moose_lib.dmv2 import _streams
-from moose_lib import cli_log, CliLogData
+from moose_lib.dmv2 import _streams, DeadLetterModel
+from moose_lib import cli_log, CliLogData, DeadLetterQueue
 
 # Force stdout to be unbuffered
 sys.stdout = io.TextIOWrapper(
@@ -37,6 +38,7 @@ sys.stdout = io.TextIOWrapper(
     line_buffering=True
 )
 
+
 @dataclasses.dataclass
 class KafkaTopicConfig:
     """
@@ -76,9 +78,10 @@ class KafkaTopicConfig:
                 name = name.removeprefix(prefix)
             else:
                 raise Exception(f"Namespace prefix {prefix} not found in topic name {name}")
-        
+
         return name
 
+
 class EnhancedJSONEncoder(json.JSONEncoder):
     """
     Custom JSON encoder that handles:
@@ -86,6 +89,7 @@ class EnhancedJSONEncoder(json.JSONEncoder):
     - dataclass instances (converts to dict)
     - Pydantic models (converts to dict)
     """
+
     def default(self, o):
         if isinstance(o, datetime):
             if o.tzinfo is None:
@@ -105,6 +109,7 @@ class EnhancedJSONEncoder(json.JSONEncoder):
             return dataclasses.asdict(o)
         return super().default(o)
 
+
 def load_streaming_function_dmv1(function_file_dir: str, function_file_name: str) -> Tuple[type, Callable]:
     """
     Load a DMV1 (legacy) streaming function from a Python module.
@@ -136,7 +141,9 @@ def load_streaming_function_dmv1(function_file_dir: str, function_file_name: str
 
     # Make sure that there is only one flow in the file
     if len(streaming_functions) != 1:
-        cli_log(CliLogData(action="Function", message=f"Expected one streaming function in the file, but got {len(streaming_functions)}", message_type="Error"))
+        cli_log(CliLogData(action="Function",
+                           message=f"Expected one streaming function in the file, but got {len(streaming_functions)}",
+                           message_type="Error"))
         sys.exit(1)
 
     # get the flow definition
@@ -150,7 +157,9 @@ def load_streaming_function_dmv1(function_file_dir: str, function_file_name: str
 
     return run_input_type, streaming_function_run
 
-def load_streaming_function_dmv2(function_file_dir: str, function_file_name: str) -> tuple[type, list[Callable]]:
+
+def load_streaming_function_dmv2(function_file_dir: str, function_file_name: str) -> tuple[
+    type, list[tuple[Callable, Optional[DeadLetterQueue]]]]:
     """
     Load a DMV2 streaming function by finding the stream transformation that matches
     the source and target topics.
@@ -162,7 +171,7 @@ def load_streaming_function_dmv2(function_file_dir: str, function_file_name: str
     Returns:
         Tuple of (input_type, transformation_functions) where:
             - input_type is the Pydantic model type of the source stream
-            - transformation_functions is a list of functions that transform source to target data
+            - transformation_functions is a list of functions that transform source to target data and their dead letter queues
             
     Raises:
         SystemExit: If module import fails or if no matching transformation is found
@@ -182,7 +191,7 @@ def load_streaming_function_dmv2(function_file_dir: str, function_file_name: str
             continue
 
         if stream.has_consumers() and target_topic is None:
-            consumers = [entry.consumer for entry in stream.consumers]
+            consumers = [(entry.consumer, entry.config.dead_letter_queue) for entry in stream.consumers]
             if not consumers:
                 continue
             return stream.model_type, consumers
@@ -193,15 +202,16 @@ def load_streaming_function_dmv2(function_file_dir: str, function_file_name: str
             # The destination topic name should match the destination stream name
             if source_py_stream_name == source_topic.topic_name_to_stream_name() and dest_stream_py_name == target_topic.topic_name_to_stream_name():
                 # Found the matching transformation
-                transformations = [entry.transformation for entry in transform_entries]
+                transformations = [(entry.transformation, entry.config.dead_letter_queue) for entry in
+                                   transform_entries]
                 if not transformations:
                     continue
                 return stream.model_type, transformations
 
     # If we get here, no matching transformation was found
     cli_log(CliLogData(
-        action="Function", 
-        message=f"No transformation found from {source_topic.name} to {target_topic.name}", 
+        action="Function",
+        message=f"No transformation found from {source_topic.name} to {target_topic.name}",
         message_type="Error"
     ))
     sys.exit(1)
@@ -215,14 +225,16 @@ parser.add_argument('source_topic_json', type=str, help='The source topic for th
 # In DMV1 the dir is the dir of the streaming function file
 # and the function_file_name is the file name of the streaming function without the .py extension
 parser.add_argument('function_file_dir', type=str, help='The dir of the streaming function file')
-parser.add_argument('function_file_name', type=str, help='The file name of the streaming function without the .py extension')
+parser.add_argument('function_file_name', type=str,
+                    help='The file name of the streaming function without the .py extension')
 parser.add_argument('broker', type=str, help='The broker to use for the streaming function')
 parser.add_argument('--target_topic_json', type=str, help='The target topic for the streaming function')
 parser.add_argument('--sasl_username', type=str, help='The SASL username to use for the streaming function')
 parser.add_argument('--sasl_password', type=str, help='The SASL password to use for the streaming function')
 parser.add_argument('--sasl_mechanism', type=str, help='The SASL mechanism to use for the streaming function')
 parser.add_argument('--security_protocol', type=str, help='The security protocol to use for the streaming function')
-parser.add_argument('--dmv2', action=argparse.BooleanOptionalAction, type=bool, help='Whether to use the DMV2 format for the streaming function')
+parser.add_argument('--dmv2', action=argparse.BooleanOptionalAction, type=bool,
+                    help='Whether to use the DMV2 format for the streaming function')
 
 args = parser.parse_args()
 
@@ -255,10 +267,12 @@ sasl_config = {
 streaming_function_id = f'flow-{source_topic.name}-{target_topic.name}' if target_topic else f'flow-{source_topic.name}'
 log_prefix = f"{source_topic.name} -> {target_topic.name}" if target_topic else f"{source_topic.name} -> None"
 
+
 def log(msg: str) -> None:
     """Log a message with the source->target topic prefix."""
     print(f"{log_prefix}: {msg}")
 
+
 def error(msg: str) -> None:
     """Raise an exception with the source->target topic prefix."""
     raise Exception(f"{log_prefix}: {msg}")
@@ -278,6 +292,7 @@ def parse_input(run_input_type: type, json_input: dict) -> Any:
     Returns:
         An instance of run_input_type populated with the JSON data
     """
+
     def deserialize(data, cls):
         if hasattr(cls, "model_validate"):  # Check if it's a Pydantic model
             return cls.model_validate(data)
@@ -292,7 +307,7 @@ def parse_input(run_input_type: type, json_input: dict) -> Any:
     return deserialize(json_input, run_input_type)
 
 
-def create_consumer():
+def create_consumer() -> KafkaConsumer:
     """
     Create a Kafka consumer configured for the source topic.
     
@@ -304,7 +319,7 @@ def create_consumer():
     if sasl_config['mechanism'] is not None:
         return KafkaConsumer(
             source_topic.name,
-            client_id= "python_streaming_function_consumer",
+            client_id="python_streaming_function_consumer",
             group_id=streaming_function_id,
             bootstrap_servers=broker,
             sasl_plain_username=sasl_config['username'],
@@ -318,13 +333,14 @@ def create_consumer():
         log("No sasl mechanism specified. Using default consumer.")
         return KafkaConsumer(
             source_topic.name,
-            client_id= "python_streaming_function_consumer",
+            client_id="python_streaming_function_consumer",
             group_id=streaming_function_id,
             bootstrap_servers=broker,
             # consumer_timeout_ms=10000,
             value_deserializer=lambda m: json.loads(m.decode('utf-8'))
         )
 
+
 def create_producer() -> Optional[KafkaProducer]:
     """
     Create a Kafka producer configured for the target topic.
@@ -334,7 +350,7 @@ def create_producer() -> Optional[KafkaProducer]:
     Returns:
         Configured KafkaProducer instance
     """
-    if sasl_config['mechanism'] is not None and target_topic is not None:
+    if sasl_config['mechanism'] is not None:
         return KafkaProducer(
             bootstrap_servers=broker,
             sasl_plain_username=sasl_config['username'],
@@ -343,16 +359,12 @@ def create_producer() -> Optional[KafkaProducer]:
             security_protocol=args.security_protocol,
             max_request_size=target_topic.max_message_bytes
         )
-    elif target_topic is not None:
-        log("No sasl mechanism specified. Using default producer.")
-        return KafkaProducer(
-            bootstrap_servers=broker,
-            max_in_flight_requests_per_connection=1,
-            max_request_size=target_topic.max_message_bytes
-        )
-    else:
-        log("No target topic specified. Not creating producer.")
-        return None
+    log("No sasl mechanism specified. Using default producer.")
+    return KafkaProducer(
+        bootstrap_servers=broker,
+        max_in_flight_requests_per_connection=1,
+        max_request_size=target_topic.max_message_bytes
+    )
 
 
 def main():
@@ -387,7 +399,7 @@ def main():
             time.sleep(1)
             with metrics_lock:
                 requests.post(
-                    "http://localhost:5001/metrics-logs", 
+                    "http://localhost:5001/metrics-logs",
                     json={
                         'timestamp': datetime.now(timezone.utc).isoformat(),
                         'count_in': metrics['count_in'],
@@ -405,30 +417,35 @@ def main():
             streaming_function_input_type = None
             streaming_function_callables = None
             if args.dmv2:
-                streaming_function_input_type, streaming_function_callables = load_streaming_function_dmv2(function_file_dir, function_file_name)
+                streaming_function_input_type, streaming_function_callables = load_streaming_function_dmv2(
+                    function_file_dir, function_file_name)
             else:
-                streaming_function_input_type, streaming_function_callable = load_streaming_function_dmv1(function_file_dir, function_file_name)
+                streaming_function_input_type, streaming_function_callable = load_streaming_function_dmv1(
+                    function_file_dir, function_file_name)
 
-                streaming_function_callables = [streaming_function_callable]
+                streaming_function_callables = [(streaming_function_callable, None)]
+
+            needs_producer = target_topic is not None or any(
+                pair[1] is not None for pair in streaming_function_callables)
 
             # Initialize Kafka connections in the processing thread
             consumer = create_consumer()
-            producer = create_producer()
-            
+            producer = create_producer() if needs_producer else None
+
             # Store references for cleanup
             kafka_refs['consumer'] = consumer
             kafka_refs['producer'] = producer
 
             # Subscribe to topic
             consumer.subscribe([source_topic.name])
-            
+
             log("Kafka consumer and producer initialized in processing thread")
 
             while running.is_set():
                 try:
                     # Poll with timeout to allow checking running state
                     messages = consumer.poll(timeout_ms=1000)
-                    
+
                     if not messages:
                         continue
 
@@ -443,8 +460,36 @@ def main():
 
                             # Run the flow
                             all_outputs = []
-                            for streaming_function_callable in streaming_function_callables:
-                                output_data = streaming_function_callable(input_data)
+                            for (streaming_function_callable, dlq) in streaming_function_callables:
+                                try:
+                                    output_data = streaming_function_callable(input_data)
+                                except Exception as e:
+                                    traceback.print_exc()
+                                    if dlq is not None:
+                                        dead_letter = DeadLetterModel(
+                                            original_record=message.value,
+                                            error_message=str(e),
+                                            error_type=e.__class__.__name__,
+                                            failed_at=datetime.now(timezone.utc),
+                                            source="transform"
+                                        )
+                                        record = dead_letter.model_dump_json().encode('utf-8')
+                                        producer.send(dlq.name, record).get()
+                                        cli_log(CliLogData(
+                                            action="DeadLetter",
+                                            message=f"Sent message to DLQ {dlq.name}: {str(e)}",
+                                            message_type=CliLogData.ERROR
+                                        ))
+                                    else:
+                                        cli_log(CliLogData(
+                                            action="Function",
+                                            message=f"Error processing message (no DLQ configured): {str(e)}",
+                                            message_type=CliLogData.ERROR
+                                        ))
+                                    # Skip to the next transformation or message
+                                    continue
+
+                                # For consumers, output_data will be None
                                 if output_data is None:
                                     continue
 
@@ -455,16 +500,17 @@ def main():
                                 with metrics_lock:
                                     metrics['count_in'] += len(output_data_list)
 
-                                cli_log(CliLogData(action="Received", message=f'{log_prefix} {len(output_data_list)} message(s)'))
+                                cli_log(CliLogData(action="Received",
+                                                   message=f'{log_prefix} {len(output_data_list)} message(s)'))
 
                             if producer is not None:
                                 for item in all_outputs:
                                     # Ignore flow function returning null
                                     if item is not None:
                                         record = json.dumps(item, cls=EnhancedJSONEncoder).encode('utf-8')
-                                        
+
                                         producer.send(target_topic.name, record)
-                                        
+
                                         with metrics_lock:
                                             metrics['bytes_count'] += len(record)
                                             metrics['count_out'] += 1
@@ -518,32 +564,33 @@ def main():
         # Ensure cleanup happens even if main thread gets interrupted
         running.clear()
         log("Shutting down threads...")
-        
+
         # Give threads a chance to exit gracefully with timeout
         metrics_thread.join(timeout=5)
         processing_thread.join(timeout=5)
-        
+
         if metrics_thread.is_alive():
             log("Metrics thread did not exit cleanly")
         if processing_thread.is_alive():
             log("Processing thread did not exit cleanly")
-        
+
         # Clean up Kafka resources regardless of thread state
         if kafka_refs['consumer']:
             try:
                 kafka_refs['consumer'].close()
             except Exception as e:
                 log(f"Error closing consumer: {e}")
-                
+
         if kafka_refs['producer'] and kafka_refs['producer'] is not None:
             try:
                 kafka_refs['producer'].flush()
                 kafka_refs['producer'].close()
             except Exception as e:
                 log(f"Error closing producer: {e}")
-        
+
         log("Shutdown complete")
         sys.exit(0)
 
+
 if __name__ == "__main__":
-    main()
+    main()

{moose_lib-0.4.160.dist-info → moose_lib-0.4.162.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: moose_lib
-Version: 0.4.160
+Version: 0.4.162
 Home-page: https://www.fiveonefour.com/moose
 Author: Fiveonefour Labs Inc.
 Author-email: support@fiveonefour.com

{moose_lib-0.4.160.dist-info → moose_lib-0.4.162.dist-info}/RECORD

@@ -1,19 +1,19 @@
 moose_lib/__init__.py,sha256=VYCFk9Nlakd24JPEj7h1cMIeqjp0eofnmE-3jCtPwXM,138
 moose_lib/blocks.py,sha256=_wdvC2NC_Y3MMEnB71WTgWbeQ--zPNHk19xjToJW0C0,3185
 moose_lib/commons.py,sha256=BV5X78MuOWHiZV9bsWSN69JIvzTNWUi-gnuMiAtaO8A,2489
-moose_lib/data_models.py,sha256=uQWRv8Y8LYlhyP_UrpENzz2-eGZDYm5Fdr5-iqrQLMo,7436
+moose_lib/data_models.py,sha256=1U8IFQaO1hR8pNGb1UTtdcGQehGgKIvLNtUFFFXC1Ko,7695
 moose_lib/dmv2-serializer.py,sha256=CL_Pvvg8tJOT8Qk6hywDNzY8MYGhMVdTOw8arZi3jng,49
-moose_lib/dmv2.py,sha256=AH5IxPK2MVOL4feXESq-4-gPcvygwRxYi0sl1SFzEko,27834
+moose_lib/dmv2.py,sha256=ahkOdAhEfi7-UN-UHOxFoAZRupO_-6zG7DfxUq9o60c,30530
 moose_lib/internal.py,sha256=URimCqQUW2aUnTmhsXWW2IHt6Gy_xuDih5fVH8SPHDI,12159
 moose_lib/main.py,sha256=In-u7yA1FsLDeP_2bhIgBtHY_BkXaZqDwf7BxwyC21c,8471
 moose_lib/query_param.py,sha256=AB5BKu610Ji-h1iYGMBZKfnEFqt85rS94kzhDwhWJnc,6288
 moose_lib/tasks.py,sha256=6MXA0j7nhvQILAJVTQHCAsquwrSOi2zAevghAc_7kXs,1554
 moose_lib/streaming/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-moose_lib/streaming/streaming_function_runner.py,sha256=UbMQhbJcQOoyit8HTNnt215hc9EOjMBiFIcToDs1c5c,22317
+moose_lib/streaming/streaming_function_runner.py,sha256=K53lyzGLawAgKgrK3jreJrB7dQfh-Cd0lcJ4je4hGJE,24362
 tests/__init__.py,sha256=0Gh4yzPkkC3TzBGKhenpMIxJcRhyrrCfxLSfpTZnPMQ,53
 tests/conftest.py,sha256=ZVJNbnr4DwbcqkTmePW6U01zAzE6QD0kNAEZjPG1f4s,169
 tests/test_moose.py,sha256=mBsx_OYWmL8ppDzL_7Bd7xR6qf_i3-pCIO3wm2iQNaA,2136
-moose_lib-0.4.160.dist-info/METADATA,sha256=zXgV6-o06hpx1ChI1VBffQV4szu5KLnOMDsA5Js1zzY,575
-moose_lib-0.4.160.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-moose_lib-0.4.160.dist-info/top_level.txt,sha256=XEns2-4aCmGp2XjJAeEH9TAUcGONLnSLy6ycT9FSJh8,16
-moose_lib-0.4.160.dist-info/RECORD,,
+moose_lib-0.4.162.dist-info/METADATA,sha256=xj7rnL729QJ5jhzALdA-zgyaiTroQudch37PwFTGfXA,575
+moose_lib-0.4.162.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+moose_lib-0.4.162.dist-info/top_level.txt,sha256=XEns2-4aCmGp2XjJAeEH9TAUcGONLnSLy6ycT9FSJh8,16
+moose_lib-0.4.162.dist-info/RECORD,,