nebu 0.1.40__py3-none-any.whl → 0.1.43__py3-none-any.whl

nebu/adapter.py

@@ -1,4 +1,5 @@
 import time
+from typing import List
 
 from pydantic import BaseModel, Field
 
@@ -14,3 +15,6 @@ class Adapter(BaseModel):
     lora_rank: int = Field(default=8)
     lora_alpha: int = Field(default=16)
     lora_dropout: float = Field(default=0.1)
+    lora_target_modules: List[str] = Field(default=[])
+    learning_rate: float = Field(default=0.0001)
+    examples_trained: int = Field(default=0)

nebu/processors/consumer.py

@@ -15,6 +15,9 @@ from redis import ConnectionError, ResponseError
 # Define TypeVar for generic models
 T = TypeVar("T")
 
+# Environment variable name used as a guard in the decorator
+_NEBU_INSIDE_CONSUMER_ENV_VAR = "_NEBU_INSIDE_CONSUMER_EXEC"
+
 # Get function and model source code and create them dynamically
 try:
     function_source = os.environ.get("FUNCTION_SOURCE")
@@ -26,8 +29,15 @@ try:
     is_stream_message = os.environ.get("IS_STREAM_MESSAGE") == "True"
     param_type_name = os.environ.get("PARAM_TYPE_NAME")
     return_type_name = os.environ.get("RETURN_TYPE_NAME")
+    param_type_str = os.environ.get("PARAM_TYPE_STR")
+    return_type_str = os.environ.get("RETURN_TYPE_STR")
     content_type_name = os.environ.get("CONTENT_TYPE_NAME")
 
+    # Get source for the file containing the decorated function
+    decorated_func_file_source = os.environ.get("DECORATED_FUNC_FILE_SOURCE")
+    # Get sources for the directory containing the decorated function
+    # decorated_dir_sources_json = os.environ.get("DECORATED_DIR_SOURCES") # Removed
+
     # Get init_func source if provided
     init_func_source = os.environ.get("INIT_FUNC_SOURCE")
     init_func_name = os.environ.get("INIT_FUNC_NAME")
@@ -103,136 +113,190 @@ try:
     exec("T = TypeVar('T')", local_namespace)
     exec("from nebu.processors.models import *", local_namespace)
     exec("from nebu.processors.processor import *", local_namespace)
+    # Add import for the processor decorator itself
+    exec("from nebu.processors.decorate import processor", local_namespace)
     # Add import for chatx openai types
     exec("from nebu.chatx.openai 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.")
+    # Set the guard environment variable before executing any source code
+    os.environ[_NEBU_INSIDE_CONSUMER_ENV_VAR] = "1"
+    print(f"[Consumer] Set environment variable {_NEBU_INSIDE_CONSUMER_ENV_VAR}=1")
 
-    # 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")
     try:
-        if module_name:
-            exec(f"import {module_name}", local_namespace)
-            print(f"Successfully imported module {module_name}")
-    except Exception as e:
-        print(f"Warning: Could not import module {module_name}: {e}")
-        print(
-            "This is expected if running in a Jupyter notebook. Will use dynamic execution."
-        )
+        # Execute the source file of the decorated function FIRST
+        if decorated_func_file_source:
+            print("[Consumer] Executing decorated function's file source...")
+            try:
+                exec(decorated_func_file_source, local_namespace)
+                print(
+                    "[Consumer] Successfully executed decorated function's file source."
+                )
+            except Exception as e:
+                print(f"Error executing decorated function's file source: {e}")
+                traceback.print_exc()  # Warn and continue
+        else:
+            print(
+                "[Consumer] No decorated function's file source found in environment."
+            )
 
-    # Define the models
-    # First define stream message class if needed
-    if stream_message_source:
-        try:
-            exec(stream_message_source, local_namespace)
-            print("Successfully defined Message class")
-        except Exception as e:
-            print(f"Error defining Message: {e}")
-            traceback.print_exc()
+        # Execute the sources from the decorated function's directory
+        # if decorated_dir_sources_json:
+        #     print("[Consumer] Executing decorated function's directory sources...")
+        #     try:
+        #         dir_sources = json.loads(decorated_dir_sources_json)
+        #         # Sort by relative path for some predictability (e.g., __init__.py first)
+        #         for rel_path, source_code in sorted(dir_sources.items()):
+        #             print(f"[Consumer] Executing source from: {rel_path}...")
+        #             try:
+        #                 exec(source_code, local_namespace)
+        #                 print(f"[Consumer] Successfully executed source from: {rel_path}")
+        #             except Exception as e:
+        #                 print(f"Error executing source from {rel_path}: {e}")
+        #                 traceback.print_exc() # Warn and continue
+        #     except json.JSONDecodeError as e:
+        #         print(f"Error decoding DECORATED_DIR_SOURCES JSON: {e}")
+        #         traceback.print_exc()
+        #     except Exception as e:
+        #         print(f"Unexpected error processing directory sources: {e}")
+        #         traceback.print_exc()
+        # else:
+        #     print("[Consumer] No decorated function's directory sources found in environment.")
+
+        # Execute included object sources NEXT, 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.")
 
-    # Define content type if available
-    if content_type_source:
+        # 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")
         try:
-            exec(content_type_source, local_namespace)
-            print(f"Successfully defined content type {content_type_name}")
-
-            # Define any content type args
-            for arg_source in content_type_args:
-                try:
-                    exec(arg_source, local_namespace)
-                    print("Successfully defined content type argument")
-                except Exception as e:
-                    print(f"Error defining content type argument: {e}")
-                    traceback.print_exc()
+            if module_name:
+                exec(f"import {module_name}", local_namespace)
+                print(f"Successfully imported module {module_name}")
         except Exception as e:
-            print(f"Error defining content type: {e}")
-            traceback.print_exc()
-
-    # Define input model if different from stream message
-    if input_model_source and (
-        not is_stream_message or input_model_source != stream_message_source
-    ):
-        try:
-            exec(input_model_source, local_namespace)
-            print(f"Successfully defined input model {param_type_name}")
+            print(f"Warning: Could not import module {module_name}: {e}")
+            print(
+                "This is expected if running in a Jupyter notebook. Will use dynamic execution."
+            )
 
-            # Define any input model args
-            for arg_source in input_model_args:
-                try:
-                    exec(arg_source, local_namespace)
-                    print("Successfully defined input model argument")
-                except Exception as e:
-                    print(f"Error defining input model argument: {e}")
-                    traceback.print_exc()
-        except Exception as e:
-            print(f"Error defining input model: {e}")
-            traceback.print_exc()
+        # Define the models
+        # First define stream message class if needed
+        if stream_message_source:
+            try:
+                exec(stream_message_source, local_namespace)
+                print("Successfully defined Message class")
+            except Exception as e:
+                print(f"Error defining Message: {e}")
+                traceback.print_exc()
 
-    # Define output model
-    if output_model_source:
-        try:
-            exec(output_model_source, local_namespace)
-            print(f"Successfully defined output model {return_type_name}")
+        # Define content type if available
+        if content_type_source:
+            try:
+                exec(content_type_source, local_namespace)
+                print(f"Successfully defined content type {content_type_name}")
+
+                # Define any content type args
+                for arg_source in content_type_args:
+                    try:
+                        exec(arg_source, local_namespace)
+                        print("Successfully defined content type argument")
+                    except Exception as e:
+                        print(f"Error defining content type argument: {e}")
+                        traceback.print_exc()
+            except Exception as e:
+                print(f"Error defining content type: {e}")
+                traceback.print_exc()
 
-            # Define any output model args
-            for arg_source in output_model_args:
-                try:
-                    exec(arg_source, local_namespace)
-                    print("Successfully defined output model argument")
-                except Exception as e:
-                    print(f"Error defining output model argument: {e}")
-                    traceback.print_exc()
-        except Exception as e:
-            print(f"Error defining output model: {e}")
-            traceback.print_exc()
+        # Define input model if different from stream message
+        if input_model_source and (
+            not is_stream_message or input_model_source != stream_message_source
+        ):
+            try:
+                exec(input_model_source, local_namespace)
+                print(f"Successfully defined input model {param_type_str}")
+
+                # Define any input model args
+                for arg_source in input_model_args:
+                    try:
+                        exec(arg_source, local_namespace)
+                        print("Successfully defined input model argument")
+                    except Exception as e:
+                        print(f"Error defining input model argument: {e}")
+                        traceback.print_exc()
+            except Exception as e:
+                print(f"Error defining input model: {e}")
+                traceback.print_exc()
 
-    # Finally, execute the function code
-    try:
-        exec(function_source, local_namespace)
-        target_function = local_namespace[function_name]
-        print(f"Successfully loaded function {function_name}")
-    except Exception as e:
-        print(f"Error creating function from source: {e}")
-        traceback.print_exc()
-        sys.exit(1)
+        # Define output model
+        if output_model_source:
+            try:
+                exec(output_model_source, local_namespace)
+                print(f"Successfully defined output model {return_type_str}")
+
+                # Define any output model args
+                for arg_source in output_model_args:
+                    try:
+                        exec(arg_source, local_namespace)
+                        print("Successfully defined output model argument")
+                    except Exception as e:
+                        print(f"Error defining output model argument: {e}")
+                        traceback.print_exc()
+            except Exception as e:
+                print(f"Error defining output model: {e}")
+                traceback.print_exc()
 
-    # Execute init_func if provided
-    if init_func_source and init_func_name:
-        print(f"Executing init_func: {init_func_name}...")
+        # Finally, execute the function code
         try:
-            exec(init_func_source, local_namespace)
-            init_function = local_namespace[init_func_name]
-            print(
-                f"[Consumer] Environment before calling init_func {init_func_name}: {os.environ}"
-            )
-            init_function()  # Call the function
-            print(f"Successfully executed init_func: {init_func_name}")
+            exec(function_source, local_namespace)
+            target_function = local_namespace[function_name]
+            print(f"Successfully loaded function {function_name}")
         except Exception as e:
-            print(f"Error executing init_func '{init_func_name}': {e}")
+            print(f"Error creating function from source: {e}")
             traceback.print_exc()
-            # Decide if failure is critical. For now, let's exit.
-            print("Exiting due to init_func failure.")
             sys.exit(1)
 
+        # Execute init_func if provided
+        if init_func_source and init_func_name:
+            print(f"Executing init_func: {init_func_name}...")
+            try:
+                exec(init_func_source, local_namespace)
+                init_function = local_namespace[init_func_name]
+                print(
+                    f"[Consumer] Environment before calling init_func {init_func_name}: {os.environ}"
+                )
+                init_function()  # Call the function
+                print(f"Successfully executed init_func: {init_func_name}")
+            except Exception as e:
+                print(f"Error executing init_func '{init_func_name}': {e}")
+                traceback.print_exc()
+                # Decide if failure is critical. For now, let's exit.
+                print("Exiting due to init_func failure.")
+                sys.exit(1)
+    finally:
+        # Unset the guard environment variable after all execs are done
+        os.environ.pop(_NEBU_INSIDE_CONSUMER_ENV_VAR, None)
+        print(f"[Consumer] Unset environment variable {_NEBU_INSIDE_CONSUMER_ENV_VAR}")
+
 except Exception as e:
     print(f"Error setting up function: {e}")
     traceback.print_exc()
@@ -412,9 +476,9 @@ def process_message(message_id: str, message_data: Dict[str, str]) -> None:
         else:
             # Otherwise use the param type directly
             try:
-                if param_type_name in local_namespace:
-                    print(f"Validating content against {param_type_name}")
-                    input_obj = local_namespace[param_type_name].model_validate(content)
+                if param_type_str in local_namespace:
+                    print(f"Validating content against {param_type_str}")
+                    input_obj = local_namespace[param_type_str].model_validate(content)
                 else:
                     # If we can't find the exact type, just pass the content directly
                     input_obj = content

nebu/processors/decorate.py

@@ -1,5 +1,6 @@
 import ast  # For parsing notebook code
 import inspect
+import os  # Add os import
 import re  # Import re for fallback check
 import textwrap
 from typing import (
@@ -39,6 +40,8 @@ R = TypeVar("R", bound=BaseModel)
 
 # Attribute name for explicitly stored source
 _NEBU_EXPLICIT_SOURCE_ATTR = "_nebu_explicit_source"
+# Environment variable to prevent decorator recursion inside consumer
+_NEBU_INSIDE_CONSUMER_ENV_VAR = "_NEBU_INSIDE_CONSUMER_EXEC"
 
 # --- Jupyter Helper Functions ---
 
@@ -356,7 +359,17 @@ def processor(
 ):
     def decorator(
         func: Callable[[Any], Any],
-    ) -> Processor:
+    ) -> Processor | Callable[[Any], Any]:  # Return type can now be original func
+        # --- Prevent Recursion Guard ---
+        # If this env var is set, we are inside the consumer's exec context.
+        # Return the original function without applying the decorator again.
+        if os.environ.get(_NEBU_INSIDE_CONSUMER_ENV_VAR) == "1":
+            print(
+                f"[DEBUG Decorator] Guard triggered for '{func.__name__}'. Returning original function."
+            )
+            return func
+        # --- End Guard ---
+
         # Moved init print here
         print(
             f"[DEBUG Decorator Init] @processor decorating function '{func.__name__}'"
@@ -833,20 +846,64 @@ def processor(
         print("[DEBUG Decorator] Finished populating environment variables.")
         # --- End Environment Variables ---
 
+        # --- Get Decorated Function's File Source ---
+        print("[DEBUG Decorator] Getting source file for decorated function...")
+        func_file_source = None
+        try:
+            func_file_path = inspect.getfile(func)
+            print(f"[DEBUG Decorator] Found file path: {func_file_path}")
+            with open(func_file_path, "r") as f:
+                func_file_source = f.read()
+            print(
+                f"[DEBUG Decorator] Successfully read source file: {func_file_path} (len: {len(func_file_source)})"
+            )
+            all_env.append(
+                V1EnvVar(key="DECORATED_FUNC_FILE_SOURCE", value=func_file_source)
+            )
+            print("[DEBUG Decorator] Added DECORATED_FUNC_FILE_SOURCE to env.")
+        except (TypeError, OSError) as e:
+            # TypeError: If func is a built-in or C function
+            # OSError: If the file cannot be opened
+            print(
+                f"Warning: Could not read source file for {processor_name}: {e}. Definitions in that file might be unavailable in the consumer."
+            )
+        except Exception as e:
+            print(
+                f"Warning: An unexpected error occurred while reading source file for {processor_name}: {e}"
+            )
+        # --- End Decorated Function's File Source ---
+
         # --- Final Setup ---
         print("[DEBUG Decorator] Preparing final Processor object...")
         metadata = V1ResourceMetaRequest(
             name=processor_name, namespace=namespace, labels=labels
         )
-        consumer_command = f"{python_cmd} -u -m nebu.processors.consumer"
-        setup_commands = [
-            f"{python_cmd} -m pip install dill pydantic redis nebu",  # Base deps
+        # Separate the final execution command from setup
+        consumer_module = "nebu.processors.consumer"
+        if "accelerate launch" in python_cmd:
+            # python_cmd is the launcher prefix (e.g., "accelerate launch")
+            # Append the module flag and the module name.
+            # Remove -u as accelerate likely handles buffering.
+            consumer_execution_command = f"{python_cmd.strip()} -m {consumer_module}"
+        else:
+            # Assume python_cmd is just the interpreter (e.g., "python")
+            consumer_execution_command = f"{python_cmd} -u -m {consumer_module}"
+
+        # Build setup commands list - run these with standard python/shell
+        setup_commands_list = [
+            "python -m pip install dill pydantic redis nebu",  # Base deps (use standard python)
         ]
         if setup_script:
-            print("[DEBUG Decorator] Adding setup script to command.")
-            setup_commands.append(f"\n{setup_script}\n")
-        setup_commands.append(consumer_command)
-        final_command = "\n".join(setup_commands)
+            print("[DEBUG Decorator] Adding setup script to setup commands.")
+            # Add setup script as raw commands
+            setup_commands_list.append(setup_script.strip())
+
+        # Combine setup commands and the final execution command
+        all_commands = setup_commands_list + [consumer_execution_command]
+        final_command = "\n\n".join(
+            all_commands
+        )  # Use double newline for clarity in logs
+
         print(
             f"[DEBUG Decorator] Final container command:\n-------\n{final_command}\n-------"
         )

nebu/processors/processor.py

@@ -1,6 +1,9 @@
+import json
+import threading
 from typing import Any, Dict, List, Optional
 
 import requests
+from pydantic import BaseModel
 
 from nebu.auth import get_user_profile
 from nebu.config import GlobalConfig
@@ -17,6 +20,64 @@ from nebu.processors.models import (
 )
 
 
+def _fetch_and_print_logs(log_url: str, api_key: str, processor_name: str):
+    """Helper function to fetch logs in a separate thread."""
+    try:
+        headers = {"Authorization": f"Bearer {api_key}"}
+        print(f"--- Attempting to stream logs for {processor_name} from {log_url} ---")
+        # Use stream=True for potentially long-lived connections and timeout
+        with requests.get(log_url, headers=headers, stream=True, timeout=300) as r:
+            r.raise_for_status()
+            print(f"--- Streaming logs for {processor_name} ---")
+            for line in r.iter_lines():
+                if not line:
+                    continue
+                try:
+                    # Decode bytes to string
+                    decoded_line = line.decode("utf-8")
+                    # Parse the JSON line
+                    log_data = json.loads(decoded_line)
+
+                    # Check if the parsed data is a dictionary (expected format)
+                    if isinstance(log_data, dict):
+                        for container, log_content in log_data.items():
+                            # Ensure log_content is a string before printing
+                            if isinstance(log_content, str):
+                                print(f"[{processor_name}][{container}] {log_content}")
+                            else:
+                                # Handle cases where log_content might not be a string
+                                print(
+                                    f"[{processor_name}][{container}] Unexpected log format: {log_content}"
+                                )
+                    else:
+                        # If not a dict, print the raw line with a warning
+                        print(
+                            f"[{processor_name}] Unexpected log structure (not a dict): {decoded_line}"
+                        )
+
+                except json.JSONDecodeError:
+                    # If JSON parsing fails, print the original line as fallback
+                    print(f"[{processor_name}] {line.decode('utf-8')} (raw/non-JSON)")
+                except Exception as e:
+                    # Catch other potential errors during line processing
+                    print(f"Error processing log line for {processor_name}: {e}")
+
+        print(f"--- Log stream ended for {processor_name} ---")
+    except requests.exceptions.Timeout:
+        print(f"Log stream connection timed out for {processor_name}.")
+    except requests.exceptions.RequestException as e:
+        # Handle potential API errors gracefully
+        print(f"Error fetching logs for {processor_name} from {log_url}: {e}")
+        if e.response is not None:
+            print(
+                f"Response status: {e.response.status_code}, Response body: {e.response.text}"
+            )
+    except Exception as e:
+        print(
+            f"An unexpected error occurred while fetching logs for {processor_name}: {e}"
+        )
+
+
 class Processor:
     """
     A class for managing Processor instances.
@@ -55,6 +116,7 @@ class Processor:
         self.max_replicas = max_replicas
         self.scale_config = scale_config
         self.processors_url = f"{self.orign_host}/v1/processors"
+        self._log_thread: Optional[threading.Thread] = None
 
         # Fetch existing Processors
         response = requests.get(
@@ -141,27 +203,67 @@ class Processor:
             patch_response.raise_for_status()
             print(f"Updated Processor {self.processor.metadata.name}")
 
-    def send(self, data: Dict[str, Any], wait: bool = False) -> Dict[str, Any]:
+    def __call__(self, data: BaseModel, wait: bool = False) -> Dict[str, Any]:
         """
-        Send data to the processor.
+        Allows the Processor instance to be called like a function, sending data.
         """
-        if not self.processor or not self.processor.metadata.name:
-            raise ValueError("Processor not found")
-
-        url = f"{self.processors_url}/{self.processor.metadata.namespace}/{self.processor.metadata.name}/messages"
+        return self.send(data=data, wait=wait)
 
+    def send(
+        self, data: BaseModel, wait: bool = False, logs: bool = False
+    ) -> Dict[str, Any]:
+        """
+        Send data to the processor and optionally stream logs in the background.
+        """
+        if (
+            not self.processor
+            or not self.processor.metadata.name
+            or not self.processor.metadata.namespace
+        ):
+            raise ValueError("Processor not found or missing metadata (name/namespace)")
+
+        processor_name = self.processor.metadata.name
+        processor_namespace = self.processor.metadata.namespace
+
+        # --- Send Data ---
+        messages_url = (
+            f"{self.processors_url}/{processor_namespace}/{processor_name}/messages"
+        )
         stream_data = V1StreamData(
             content=data,
             wait=wait,
         )
-
         response = requests.post(
-            url,
+            messages_url,
             json=stream_data.model_dump(mode="json", exclude_none=True),
             headers={"Authorization": f"Bearer {self.api_key}"},
         )
         response.raise_for_status()
-        return response.json()
+        send_response_json = response.json()
+
+        # --- Fetch Logs (if requested and not already running) ---
+        if logs:
+            if self._log_thread is None or not self._log_thread.is_alive():
+                log_url = (
+                    f"{self.processors_url}/{processor_namespace}/{processor_name}/logs"
+                )
+                self._log_thread = threading.Thread(
+                    target=_fetch_and_print_logs,
+                    args=(log_url, self.api_key, processor_name),  # Pass processor_name
+                    daemon=True,
+                )
+                try:
+                    self._log_thread.start()
+                    print(f"Started background log fetching for {processor_name}...")
+                except Exception as e:
+                    print(
+                        f"Failed to start log fetching thread for {processor_name}: {e}"
+                    )
+                    self._log_thread = None  # Reset if start fails
+            else:
+                print(f"Log fetching is already running for {processor_name}.")
+
+        return send_response_json
 
     def scale(self, replicas: int) -> Dict[str, Any]:
         """
@@ -277,3 +379,21 @@ class Processor:
         Get the resource ref for the processor.
         """
         return f"{self.name}.{self.namespace}.Processor"
+
+    def stop_logs(self):
+        """
+        Signals the intent to stop the background log stream.
+        Note: Interrupting a streaming requests.get cleanly can be complex.
+              This currently allows a new log stream to be started on the next call.
+        """
+        if self._log_thread and self._log_thread.is_alive():
+            # Attempting to stop a daemon thread directly isn't standard practice.
+            # Setting the reference to None allows a new thread to be created if needed.
+            # The OS will eventually clean up the daemon thread when the main process exits,
+            # or potentially sooner if the network request completes or errors out.
+            print(
+                f"Disassociating from active log stream for {self.name}. A new stream can be started."
+            )
+            self._log_thread = None
+        else:
+            print(f"No active log stream to stop for {self.name}.")

{nebu-0.1.40.dist-info → nebu-0.1.43.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nebu
-Version: 0.1.40
+Version: 0.1.43
 Summary: A globally distributed container runtime
 Requires-Python: >=3.10.14
 Description-Content-Type: text/markdown
@@ -10,7 +10,6 @@ Requires-Dist: dill>=0.3.8
 Requires-Dist: openai>=1.68.2
 Requires-Dist: pillow>=11.1.0
 Requires-Dist: pydantic>=2.10.6
-Requires-Dist: pydantic-ai-slim[openai]>=0.0.55
 Requires-Dist: pysocks>=1.7.1
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: redis[socks]>=5.0

{nebu-0.1.40.dist-info → nebu-0.1.43.dist-info}/RECORD

@@ -1,5 +1,5 @@
 nebu/__init__.py,sha256=5sepbzdAdoA_8TIxws60S4ugFY1apQd_savzn20a4cY,465
-nebu/adapter.py,sha256=X9Lc0-pm4U6v7UDgOd_RuxJqENqAO8Si4jrwGYTsMGI,418
+nebu/adapter.py,sha256=lqpvfY_up-qVvWxxfYKLFXkYvlEilv-BrRNt554cixU,591
 nebu/auth.py,sha256=N_v6SPFD9HU_UoRDTaouH03g2Hmo9C-xxqInE1FweXE,1471
 nebu/cache.py,sha256=jmluqvWnE9N8uNq6nppXSxEJK7DKWaB79GicaGg9KmY,4718
 nebu/config.py,sha256=aZzQltkobtOLHFCGcIkpKoE3ITn3Z11Dp0E72w84TA0,5769
@@ -11,16 +11,16 @@ nebu/containers/container.py,sha256=yb7KaPTVXnEEAlrpdlUi4HNqF6P7z9bmwAILGlq6iqU,
 nebu/containers/decorator.py,sha256=uFtzlAXRHYZECJ-NPusY7oN9GXvdHrHDd_JNrIGr8aQ,3244
 nebu/containers/models.py,sha256=0j6NGy4yto-enRDh_4JH_ZTbHrLdSpuMOqNQPnIrwC4,6815
 nebu/containers/server.py,sha256=yFa2Y9PzBn59E1HftKiv0iapPonli2rbGAiU6r-wwe0,2513
-nebu/processors/consumer.py,sha256=vVbA6PdgkTKI5iqCDSnHO0dtbyFPiK7_1ys3ph7xPrk,20786
-nebu/processors/decorate.py,sha256=KZ43vOPzl3HVPB9P3QX6U94yTBnVi7ISoXQhUuEMO7g,38156
+nebu/processors/consumer.py,sha256=qQleTn5BmaZvlH4YkrZqqEZNvMJDv5RpKRVRHX28Qs0,24496
+nebu/processors/decorate.py,sha256=T-nnsu85eH5ui-66E0IJfMj5KG1fMDHeSmj4oT2scZA,40990
 nebu/processors/default.py,sha256=W4slJenG59rvyTlJ7gRp58eFfXcNOTT2Hfi6zzJAobI,365
 nebu/processors/models.py,sha256=y40HoW-MEzDWB2dm_tsYlUy3Nf3s6eiLC0iGO9BoNog,3956
-nebu/processors/processor.py,sha256=068hLQKapWabNlhb_DtzqAJ7N7MGdr5UcjfZrb_MkFo,9732
+nebu/processors/processor.py,sha256=cptZEN9ZGcaoFNreaw3BkwV0qKHvjP9b4nNxlQjFT3s,15405
 nebu/processors/remote.py,sha256=TeAIPGEMqnDIb7H1iett26IEZrBlcbPB_-DSm6jcH1E,1285
 nebu/redis/models.py,sha256=coPovAcVXnOU1Xh_fpJL4PO3QctgK9nBe5QYoqEcnxg,1230
 nebu/services/service.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nebu-0.1.40.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-nebu-0.1.40.dist-info/METADATA,sha256=bYppJEpxIjbq5HgALjImHajrlBkyEp63EuKAp19drHo,1786
-nebu-0.1.40.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-nebu-0.1.40.dist-info/top_level.txt,sha256=uLIbEKJeGSHWOAJN5S0i5XBGwybALlF9bYoB1UhdEgQ,5
-nebu-0.1.40.dist-info/RECORD,,
+nebu-0.1.43.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+nebu-0.1.43.dist-info/METADATA,sha256=6oxUDToyMBXQWgcNZd7LaYF3DIi-gCGU1b-bVLzesK0,1738
+nebu-0.1.43.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+nebu-0.1.43.dist-info/top_level.txt,sha256=uLIbEKJeGSHWOAJN5S0i5XBGwybALlF9bYoB1UhdEgQ,5
+nebu-0.1.43.dist-info/RECORD,,