nebu 0.1.14__py3-none-any.whl → 0.1.16__py3-none-any.whl

nebu/processors/consumer.py

@@ -97,6 +97,26 @@ try:
     exec("from nebu.processors.models import *", local_namespace)
     exec("from nebu.processors.processor import *", local_namespace)
 
+    # Execute included object sources FIRST, as they might define types needed by others
+    print("[Consumer] Executing included object sources...")
+    for i, (obj_source, args_sources) in enumerate(included_object_sources):
+        try:
+            exec(obj_source, local_namespace)
+            print(f"[Consumer] Successfully executed included object {i} base source")
+            for j, arg_source in enumerate(args_sources):
+                try:
+                    exec(arg_source, local_namespace)
+                    print(
+                        f"[Consumer] Successfully executed included object {i} arg {j} source"
+                    )
+                except Exception as e:
+                    print(f"Error executing included object {i} arg {j} source: {e}")
+                    traceback.print_exc()
+        except Exception as e:
+            print(f"Error executing included object {i} base source: {e}")
+            traceback.print_exc()
+    print("[Consumer] Finished executing included object sources.")
+
     # First try to import the module to get any needed dependencies
     # This is a fallback in case the module is available
     module_name = os.environ.get("MODULE_NAME")
@@ -176,22 +196,6 @@ try:
             print(f"Error defining output model: {e}")
             traceback.print_exc()
 
-    # Execute included object sources
-    for i, (obj_source, args_sources) in enumerate(included_object_sources):
-        try:
-            exec(obj_source, local_namespace)
-            print(f"Successfully executed included object {i} base source")
-            for j, arg_source in enumerate(args_sources):
-                try:
-                    exec(arg_source, local_namespace)
-                    print(f"Successfully executed included object {i} arg {j} source")
-                except Exception as e:
-                    print(f"Error executing included object {i} arg {j} source: {e}")
-                    traceback.print_exc()
-        except Exception as e:
-            print(f"Error executing included object {i} base source: {e}")
-            traceback.print_exc()
-
     # Finally, execute the function code
     try:
         exec(function_source, local_namespace)

nebu/processors/decorate.py

@@ -1,6 +1,17 @@
 import inspect
+import re  # Import re for fallback check
 import textwrap
-from typing import Any, Callable, Dict, List, Optional, TypeVar, get_type_hints
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    List,
+    Optional,
+    TypeVar,
+    get_args,
+    get_origin,
+    get_type_hints,
+)
 
 from pydantic import BaseModel
 
@@ -31,6 +42,7 @@ def get_model_source(model_class: Any) -> Optional[str]:
         source = inspect.getsource(model_class)
         return textwrap.dedent(source)
     except (IOError, TypeError):
+        print(f"[DEBUG get_model_source] Failed for: {model_class}")  # Added debug
         return None
 
 
@@ -41,19 +53,28 @@ def get_type_source(type_obj: Any) -> Optional[Any]:
         return get_model_source(type_obj)
 
     # If it's a GenericAlias (like V1StreamMessage[SomeType])
-    if hasattr(type_obj, "__origin__") and hasattr(type_obj, "__args__"):
-        origin_source = get_model_source(type_obj.__origin__)
+    # Use get_origin and get_args for robustness
+    origin = get_origin(type_obj)
+    args = get_args(type_obj)
+
+    if origin is not None:
+        origin_source = get_model_source(origin)
         args_sources = []
 
         # Get sources for all type arguments
-        for arg in type_obj.__args__:
+        for arg in args:
             arg_source = get_type_source(arg)
             if arg_source:
                 args_sources.append(arg_source)
 
-        return origin_source, args_sources
+        # Return tuple only if origin source and some arg sources were found
+        if origin_source or args_sources:
+            return (
+                origin_source,
+                args_sources,
+            )  # Return even if origin_source is None if args_sources exist
 
-    return None
+    return None  # Fallback if not a class or recognizable generic alias
 
 
 def processor(
@@ -98,112 +119,215 @@ def processor(
         include: Optional list of Python objects whose source code should be included
     """
 
-    def decorator(func: Callable[[T], R]) -> Processor:
-        # Validate that the function takes a single parameter that is a BaseModel
+    def decorator(
+        func: Callable[[Any], Any],
+    ) -> Processor:  # Changed T/R to Any for broader compatibility
+        # Prepare environment variables early
+        all_env = env or []
+
+        # --- Process Included Objects First ---
+        included_sources: Dict[Any, Any] = {}  # Store source keyed by the object itself
+        if include:
+            print(f"[DEBUG Decorator] Processing included objects: {include}")
+            for i, obj in enumerate(include):
+                # Directly use get_model_source as include expects types/classes usually
+                obj_source = get_model_source(obj)
+                if obj_source:
+                    print(f"[DEBUG Decorator] Found source for included object: {obj}")
+                    included_sources[obj] = obj_source  # Store source by object
+                    # Add to env vars immediately (simplifies later logic)
+                    env_key = f"INCLUDED_OBJECT_{i}_SOURCE"
+                    all_env.append(V1EnvVar(key=env_key, value=obj_source))
+                    print(f"[DEBUG Decorator] Added {env_key} for {obj}")
+
+                else:
+                    # Optionally raise an error or log a warning if source can't be found
+                    print(
+                        f"Warning: Could not retrieve source via get_model_source for included object: {obj}. Decorator might fail if this type is needed but cannot be auto-detected."
+                    )
+            print(
+                f"[DEBUG Decorator] Finished processing included objects. Sources found: {len(included_sources)}"
+            )
+        # --- End Included Objects Processing ---
+
+        # Validate function signature
         sig = inspect.signature(func)
         params = list(sig.parameters.values())
 
         if len(params) != 1:
             raise TypeError(f"Function {func.__name__} must take exactly one parameter")
 
-        # Check parameter type
-        type_hints = get_type_hints(func)
+        # Check parameter type hint
+        try:
+            # Use eval_str=True for forward references if needed, requires Python 3.10+ globals/locals
+            type_hints = get_type_hints(
+                func, globalns=func.__globals__, localns=None
+            )  # Pass globals
+        except Exception as e:
+            print(
+                f"[DEBUG Decorator] Error getting type hints for {func.__name__}: {e}"
+            )
+            raise TypeError(
+                f"Could not evaluate type hints for {func.__name__}. Ensure all types are defined or imported."
+            ) from e
+
         param_name = params[0].name
         if param_name not in type_hints:
             raise TypeError(
                 f"Parameter {param_name} in function {func.__name__} must have a type annotation"
             )
-
         param_type = type_hints[param_name]
 
-        # Check if input type is V1StreamMessage or a subclass
+        # --- Determine Input Type, Content Type, and is_stream_message ---
+        print(f"[DEBUG Decorator] Full type_hints: {type_hints}")
+        print(f"[DEBUG Decorator] Detected param_type: {param_type}")
+        origin = get_origin(param_type)
+        args = get_args(param_type)
+        print(f"[DEBUG Decorator] Param type origin (using get_origin): {origin}")
+        print(f"[DEBUG Decorator] Param type args (using get_args): {args}")
+        if origin:
+            print(
+                f"[DEBUG Decorator] Origin name: {getattr(origin, '__name__', 'N/A')}, module: {getattr(origin, '__module__', 'N/A')}"
+            )
+            print(
+                f"[DEBUG Decorator] V1StreamMessage name: {V1StreamMessage.__name__}, module: {V1StreamMessage.__module__}"
+            )
+
         is_stream_message = False
         content_type = None
 
-        # Handle generic V1StreamMessage
+        # Check 1: Standard check using get_origin
         if (
-            hasattr(param_type, "__origin__")
-            and param_type.__origin__ == V1StreamMessage
+            origin is not None
+            and origin.__name__ == V1StreamMessage.__name__
+            and origin.__module__ == V1StreamMessage.__module__
         ):
             is_stream_message = True
-            # Extract the content type from V1StreamMessage[ContentType]
-            if hasattr(param_type, "__args__") and param_type.__args__:
-                content_type = param_type.__args__[0]
-        # Handle direct V1StreamMessage
+            print("[DEBUG Decorator] V1StreamMessage detected via origin check.")
+            if args:
+                content_type = args[0]
+
+        # Check 2: Fallback check using string representation
+        elif origin is None:
+            type_str = str(param_type)
+            match = re.match(
+                r"<class 'nebu\.processors\.models\.V1StreamMessage\[(.*)\]\'>",
+                type_str,
+            )
+            if match:
+                print(
+                    "[DEBUG Decorator] V1StreamMessage detected via string regex check (origin/args failed)."
+                )
+                content_type_name = match.group(1)
+                print(
+                    f"[DEBUG Decorator] Manually parsed content_type name: {content_type_name}"
+                )
+                # Attempt to find the type
+                resolved_type = None
+                func_globals = func.__globals__
+                if content_type_name in func_globals:
+                    resolved_type = func_globals[content_type_name]
+                    print(
+                        f"[DEBUG Decorator] Found content type '{content_type_name}' in function globals."
+                    )
+                else:
+                    func_module = inspect.getmodule(func)
+                    if func_module and hasattr(func_module, content_type_name):
+                        resolved_type = getattr(func_module, content_type_name)
+                        print(
+                            f"[DEBUG Decorator] Found content type '{content_type_name}' in function module."
+                        )
+
+                if resolved_type:
+                    content_type = resolved_type
+                    is_stream_message = True  # Set flag *only if* resolved
+                else:
+                    print(
+                        f"[DEBUG Decorator] Fallback failed: Could not find type '{content_type_name}' in globals or module. Use 'include'."
+                    )
+            # else: Fallback regex did not match
+
+        # Check 3: Handle direct V1StreamMessage
         elif param_type is V1StreamMessage:
+            print("[DEBUG Decorator] V1StreamMessage detected via direct type check.")
             is_stream_message = True
+            # content_type remains None
 
-        # Ensure the parameter is a BaseModel
-        actual_type = (
-            param_type.__origin__ if hasattr(param_type, "__origin__") else param_type  # type: ignore
-        )
-        if not issubclass(actual_type, BaseModel):
-            raise TypeError(
-                f"Parameter {param_name} in function {func.__name__} must be a BaseModel"
+        print(f"[DEBUG Decorator] Final is_stream_message: {is_stream_message}")
+        print(f"[DEBUG Decorator] Final content_type: {content_type}")
+        # --- End Input Type Determination ---
+
+        # --- Validate Parameter Type is BaseModel ---
+        type_to_check_for_basemodel = None
+        if is_stream_message:
+            if content_type:
+                type_to_check_for_basemodel = content_type
+            # else: Base V1StreamMessage itself is a BaseModel, no need to check further
+        else:
+            type_to_check_for_basemodel = param_type
+
+        if type_to_check_for_basemodel:
+            actual_type_to_check = (
+                get_origin(type_to_check_for_basemodel) or type_to_check_for_basemodel
             )
+            if not issubclass(actual_type_to_check, BaseModel):
+                raise TypeError(
+                    f"Parameter '{param_name}' effective type ({actual_type_to_check.__name__}) in function '{func.__name__}' must be a BaseModel subclass"
+                )
+        # --- End Parameter Validation ---
 
-        # Check return type
+        # --- Validate Return Type ---
         if "return" not in type_hints:
             raise TypeError(
                 f"Function {func.__name__} must have a return type annotation"
             )
-
         return_type = type_hints["return"]
-        actual_return_type = (
-            return_type.__origin__
-            if hasattr(return_type, "__origin__")
-            else return_type
-        )
+        actual_return_type = get_origin(return_type) or return_type
         if not issubclass(actual_return_type, BaseModel):
             raise TypeError(
-                f"Return value of function {func.__name__} must be a BaseModel"
+                f"Return value of function {func.__name__} must be a BaseModel subclass"
             )
+        # --- End Return Type Validation ---
 
-        # Get function name to use as processor name
+        # --- Get Function Source ---
         processor_name = func.__name__
-
-        # Prepare environment variables
-        all_env = env or []
-
-        # Get the source code of the function
         try:
             raw_function_source = inspect.getsource(func)
-            print(
-                f"[DEBUG Decorator] Raw source for {func.__name__}:\n{raw_function_source}"
-            )
-
-            # Clean up the indentation
-            dedented_function_source = textwrap.dedent(raw_function_source)
-            print(
-                f"[DEBUG Decorator] Dedented source for {func.__name__}:\n{dedented_function_source}"
-            )
-
-            # Find the start of the function definition ('def')
-            # Skip lines starting with '@' or empty lines until 'def' is found
-            lines = dedented_function_source.splitlines()
+            # ... (rest of source processing remains the same) ...
+            lines = raw_function_source.splitlines()
             func_def_index = -1
+            decorator_lines = 0
+            in_decorator = False
             for i, line in enumerate(lines):
                 stripped_line = line.strip()
+                if stripped_line.startswith("@"):
+                    in_decorator = True
+                    decorator_lines += 1
+                    continue  # Skip decorator line
+                if in_decorator and stripped_line.endswith(
+                    ")"
+                ):  # Simple check for end of decorator args
+                    in_decorator = False
+                    decorator_lines += 1
+                    continue
+                if in_decorator:
+                    decorator_lines += 1
+                    continue  # Skip multi-line decorator args
+
                 if stripped_line.startswith("def "):
                     func_def_index = i
                     break
-                # Simply continue if it's not the def line.
-                # This skips decorators and their arguments, regardless of multi-line formatting.
-                continue
 
             if func_def_index != -1:
                 # Keep lines from the 'def' line onwards
-                function_source = "\n".join(
-                    lines[func_def_index:]
-                )  # Use \n for env var
+                function_source = "\n".join(lines[func_def_index:])
             else:
-                # If 'def' wasn't found (shouldn't happen with valid function source)
                 raise ValueError(
                     f"Could not find function definition 'def' in source for {func.__name__}"
                 )
 
             print(
-                f"[DEBUG Decorator] Processed function source for {func.__name__}:\n{function_source}"
+                f"[DEBUG Decorator] Processed function source for {func.__name__}:\n{function_source[:200]}..."
             )
 
         except (IOError, TypeError) as e:
@@ -211,161 +335,135 @@ def processor(
             raise ValueError(
                 f"Could not retrieve source code for function {func.__name__}: {e}"
             ) from e
+        # --- End Function Source ---
 
-        # Get source code for the models
+        # --- Get Model Sources (Prioritizing Included) ---
         input_model_source = None
         output_model_source = None
         content_type_source = None
-
-        # Get the V1StreamMessage class source
-        stream_message_source = get_model_source(V1StreamMessage)
-
-        # Get input model source
-        if is_stream_message:
-            input_model_source = stream_message_source
-            if content_type:
-                content_type_source = get_type_source(content_type)
-        else:
-            input_model_source = get_type_source(param_type)
-
-        # Get output model source
-        output_model_source = get_type_source(return_type)
-
-        # Add function source code to environment variables
-        print(
-            f"[DEBUG Decorator] Setting FUNCTION_SOURCE: {function_source[:100]}..."
-        )  # Print first 100 chars
-        all_env.append(V1EnvVar(key="FUNCTION_SOURCE", value=function_source))
-        print(f"[DEBUG Decorator] Setting FUNCTION_NAME: {func.__name__}")
-        all_env.append(V1EnvVar(key="FUNCTION_NAME", value=func.__name__))
-
-        # Add model source codes
-        if input_model_source:
-            if isinstance(input_model_source, tuple):
-                all_env.append(
-                    V1EnvVar(key="INPUT_MODEL_SOURCE", value=input_model_source[0])
+        stream_message_source = get_model_source(V1StreamMessage)  # Still get this
+
+        # Get content_type source (if applicable)
+        if is_stream_message and content_type:
+            if content_type in included_sources:
+                content_type_source = included_sources[content_type]
+                print(
+                    f"[DEBUG Decorator] Using included source for content_type: {content_type}"
                 )
-                # Add generic args sources
-                for i, arg_source in enumerate(input_model_source[1]):
-                    all_env.append(
-                        V1EnvVar(key=f"INPUT_MODEL_ARG_{i}_SOURCE", value=arg_source)
-                    )
             else:
-                all_env.append(
-                    V1EnvVar(key="INPUT_MODEL_SOURCE", value=input_model_source)
-                )
-
-        if output_model_source:
-            if isinstance(output_model_source, tuple):
-                all_env.append(
-                    V1EnvVar(key="OUTPUT_MODEL_SOURCE", value=output_model_source[0])
+                print(
+                    f"[DEBUG Decorator] Attempting get_type_source for content_type: {content_type}"
                 )
-                # Add generic args sources
-                for i, arg_source in enumerate(output_model_source[1]):
-                    all_env.append(
-                        V1EnvVar(key=f"OUTPUT_MODEL_ARG_{i}_SOURCE", value=arg_source)
+                content_type_source = get_type_source(content_type)
+                if content_type_source is None:
+                    print(
+                        f"[DEBUG Decorator] Warning: get_type_source failed for content_type: {content_type}. Consumer might fail if not included."
                     )
-            else:
-                all_env.append(
-                    V1EnvVar(key="OUTPUT_MODEL_SOURCE", value=output_model_source)
-                )
 
-        if stream_message_source:
-            all_env.append(
-                V1EnvVar(key="STREAM_MESSAGE_SOURCE", value=stream_message_source)
+            print(
+                f"[DEBUG Decorator] Final content_type_source: {str(content_type_source)[:100]}..."
             )
 
-        if content_type_source:
-            if isinstance(content_type_source, tuple):
-                all_env.append(
-                    V1EnvVar(key="CONTENT_TYPE_SOURCE", value=content_type_source[0])
+        # Get input_model source (which is V1StreamMessage if is_stream_message)
+        if is_stream_message:
+            input_model_source = (
+                stream_message_source  # Always use base stream message source
+            )
+        elif (
+            param_type in included_sources
+        ):  # Check if non-stream-message input type was included
+            input_model_source = included_sources[param_type]
+            print(
+                f"[DEBUG Decorator] Using included source for param_type: {param_type}"
+            )
+        else:  # Fallback for non-stream-message, non-included input type
+            print(
+                f"[DEBUG Decorator] Attempting get_type_source for param_type: {param_type}"
+            )
+            input_model_source = get_type_source(param_type)
+            if input_model_source is None:
+                print(
+                    f"[DEBUG Decorator] Warning: get_type_source failed for param_type: {param_type}. Consumer might fail if not included."
                 )
-                # Add generic args sources for content type
-                for i, arg_source in enumerate(content_type_source[1]):
-                    all_env.append(
-                        V1EnvVar(key=f"CONTENT_TYPE_ARG_{i}_SOURCE", value=arg_source)
-                    )
-            else:
-                all_env.append(
-                    V1EnvVar(key="CONTENT_TYPE_SOURCE", value=content_type_source)
+        print(
+            f"[DEBUG Decorator] Final input_model_source: {str(input_model_source)[:100]}..."
+        )
+
+        # Get output_model source
+        if return_type in included_sources:
+            output_model_source = included_sources[return_type]
+            print(
+                f"[DEBUG Decorator] Using included source for return_type: {return_type}"
+            )
+        else:
+            print(
+                f"[DEBUG Decorator] Attempting get_type_source for return_type: {return_type}"
+            )
+            output_model_source = get_type_source(return_type)
+            if output_model_source is None:
+                print(
+                    f"[DEBUG Decorator] Warning: get_type_source failed for return_type: {return_type}. Consumer might fail if not included."
                 )
+        print(
+            f"[DEBUG Decorator] Final output_model_source: {str(output_model_source)[:100]}..."
+        )
+        # --- End Model Sources ---
 
-        # Add included object sources
-        if include:
-            for i, obj in enumerate(include):
-                obj_source = get_type_source(
-                    obj
-                )  # Reuse existing function for source retrieval
-                if obj_source:
-                    if isinstance(obj_source, tuple):
-                        # Handle complex types (like generics) if needed, similar to models
+        # --- Populate Environment Variables ---
+        print("[DEBUG Decorator] Populating environment variables...")
+        all_env.append(V1EnvVar(key="FUNCTION_SOURCE", value=function_source))
+        all_env.append(V1EnvVar(key="FUNCTION_NAME", value=func.__name__))
+
+        # Add model source codes (handle tuples from get_type_source if necessary, although unlikely with prioritization)
+        def add_source_to_env(key_base: str, source: Any):
+            if source:
+                if isinstance(source, tuple):
+                    # This path is less likely now with include prioritization
+                    if source[0]:  # Origin source
                         all_env.append(
-                            V1EnvVar(
-                                key=f"INCLUDED_OBJECT_{i}_SOURCE", value=obj_source[0]
-                            )
+                            V1EnvVar(key=f"{key_base}_SOURCE", value=source[0])
                         )
-                        for j, arg_source in enumerate(obj_source[1]):
-                            all_env.append(
-                                V1EnvVar(
-                                    key=f"INCLUDED_OBJECT_{i}_ARG_{j}_SOURCE",
-                                    value=arg_source,
-                                )
-                            )
-                    else:
+                    for i, arg_source in enumerate(source[1]):  # Arg sources
                         all_env.append(
-                            V1EnvVar(
-                                key=f"INCLUDED_OBJECT_{i}_SOURCE", value=obj_source
-                            )
+                            V1EnvVar(key=f"{key_base}_ARG_{i}_SOURCE", value=arg_source)
                         )
-                else:
-                    # Optionally raise an error or log a warning if source can't be found
-                    print(
-                        f"Warning: Could not retrieve source for included object: {obj}"
-                    )
+                else:  # Simple string source
+                    all_env.append(V1EnvVar(key=f"{key_base}_SOURCE", value=source))
+
+        add_source_to_env("INPUT_MODEL", input_model_source)
+        add_source_to_env("OUTPUT_MODEL", output_model_source)
+        add_source_to_env("CONTENT_TYPE", content_type_source)
+        add_source_to_env(
+            "STREAM_MESSAGE", stream_message_source
+        )  # Add base stream message source
 
-        # Add parameter and return type info for runtime validation
+        # Type names for consumer validation/parsing
         all_env.append(
             V1EnvVar(
-                key="PARAM_TYPE_NAME",
-                value=param_type.__name__
-                if hasattr(param_type, "__name__")
-                else str(param_type),
-            )
+                key="PARAM_TYPE_STR", value=str(param_type)
+            )  # Send string representation
         )
         all_env.append(
             V1EnvVar(
-                key="RETURN_TYPE_NAME",
-                value=return_type.__name__
-                if hasattr(return_type, "__name__")
-                else str(return_type),
-            )
+                key="RETURN_TYPE_STR", value=str(return_type)
+            )  # Send string representation
         )
         all_env.append(V1EnvVar(key="IS_STREAM_MESSAGE", value=str(is_stream_message)))
-
         if content_type:
             all_env.append(
-                V1EnvVar(
-                    key="CONTENT_TYPE_NAME",
-                    value=content_type.__name__
-                    if hasattr(content_type, "__name__")
-                    else str(content_type),
-                )
+                V1EnvVar(key="CONTENT_TYPE_NAME", value=content_type.__name__)
             )
 
-        # We still add the module for reference, but we won't rely on importing it
         all_env.append(V1EnvVar(key="MODULE_NAME", value=func.__module__))
+        # --- End Environment Variables ---
 
-        # Prepare metadata
+        # --- Final Setup ---
         metadata = V1ResourceMetaRequest(
             name=processor_name, namespace=namespace, labels=labels
         )
-
-        # Create the command to run the consumer directly
         consumer_command = f"{python_cmd} -m nebu.processors.consumer"
+        final_command = f"{python_cmd} -m pip install redis nebu\n\n{setup_script or ''}\n\n{consumer_command}"
 
-        final_command = f"{python_cmd} -m pip install redis nebu\n\n{setup_script}\n\n{consumer_command}"
-
-        # Create the V1ContainerRequest
         container_request = V1ContainerRequest(
             image=image,
             command=final_command,
@@ -379,16 +477,19 @@ def processor(
             platform=platform,
             metadata=metadata,
         )
-        print("container_request", container_request)
+        print("[DEBUG Decorator] Final Container Request Env Vars:")
+        for env_var in all_env:
+            print(
+                f"[DEBUG Decorator]  {env_var.key}: {str(env_var.value)[:70]}..."
+            )  # Print key and start of value
 
-        # Create the processor instance
         processor_instance = Processor(
             name=processor_name,
-            stream=processor_name,
+            stream=processor_name,  # Default stream name to processor name
             namespace=namespace,
             labels=labels,
             container=container_request,
-            schema_=None,  # TODO
+            schema_=None,
             common_schema=None,
             min_replicas=min_replicas,
             max_replicas=max_replicas,

{nebu-0.1.14.dist-info → nebu-0.1.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nebu
-Version: 0.1.14
+Version: 0.1.16
 Summary: A globally distributed container runtime
 Requires-Python: >=3.10.14
 Description-Content-Type: text/markdown

{nebu-0.1.14.dist-info → nebu-0.1.16.dist-info}/RECORD

@@ -6,15 +6,15 @@ nebu/containers/container.py,sha256=yb7KaPTVXnEEAlrpdlUi4HNqF6P7z9bmwAILGlq6iqU,
 nebu/containers/decorator.py,sha256=qiM7hbHne9MhSp1gDgX5z5bimsXr_YPjTIZoe09dwr4,2741
 nebu/containers/models.py,sha256=0j6NGy4yto-enRDh_4JH_ZTbHrLdSpuMOqNQPnIrwC4,6815
 nebu/containers/server.py,sha256=yFa2Y9PzBn59E1HftKiv0iapPonli2rbGAiU6r-wwe0,2513
-nebu/processors/consumer.py,sha256=OrhiG6qW4CcKXaNcTHV4AqXZ5M01JRFXbZhmNdU5Nsg,15232
-nebu/processors/decorate.py,sha256=coIHJ6p1GhGqgoDFhNSrWRLAdpDooenr-L6JwGghRck,14953
+nebu/processors/consumer.py,sha256=LsMfh-Ai1goxolQiw913Tj9bYLR0Ji3OXp3LGFFoiQ8,15480
+nebu/processors/decorate.py,sha256=NwuV0uY1weAM472VntfyYKd0tTsqtFCPrNGhF4vJP6I,20492
 nebu/processors/default.py,sha256=W4slJenG59rvyTlJ7gRp58eFfXcNOTT2Hfi6zzJAobI,365
 nebu/processors/models.py,sha256=GvnI8UJrQSjHo2snP07cPfisCH90cEGTY-PZV5_AtXI,3654
 nebu/processors/processor.py,sha256=oy2YdI-cy6qQWxrZhpZahJV46oWZlu_Im-jm811R_oo,9667
 nebu/redis/models.py,sha256=coPovAcVXnOU1Xh_fpJL4PO3QctgK9nBe5QYoqEcnxg,1230
 nebu/services/service.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nebu-0.1.14.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-nebu-0.1.14.dist-info/METADATA,sha256=Lo_6Ww5-zJ8MCZ7yPqCYrK1OtKOF9KpmR-ytN2FG24o,1588
-nebu-0.1.14.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-nebu-0.1.14.dist-info/top_level.txt,sha256=uLIbEKJeGSHWOAJN5S0i5XBGwybALlF9bYoB1UhdEgQ,5
-nebu-0.1.14.dist-info/RECORD,,
+nebu-0.1.16.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+nebu-0.1.16.dist-info/METADATA,sha256=TN23ux4MnSCtVx4I23hiai9S-ROhFmza8-qCAw0f9Pw,1588
+nebu-0.1.16.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+nebu-0.1.16.dist-info/top_level.txt,sha256=uLIbEKJeGSHWOAJN5S0i5XBGwybALlF9bYoB1UhdEgQ,5
+nebu-0.1.16.dist-info/RECORD,,