nebu 0.1.88__py3-none-any.whl → 0.1.93__py3-none-any.whl

nebu/processors/decorate.py

@@ -1,7 +1,7 @@
 import ast  # For parsing notebook code
 import inspect
 import os
-import re  # Added import
+import re
 import textwrap
 from typing import (
     Any,
@@ -36,6 +36,7 @@ from nebu.containers.models import (
     V1VolumePath,
 )
 from nebu.data import Bucket
+from nebu.logging import logger
 from nebu.meta import V1ResourceMetaRequest
 from nebu.processors.models import (
     Message,
@@ -78,19 +79,19 @@ def is_jupyter_notebook():
 
         ip = get_ipython()  # Use the imported function
         if ip is None:  # type: ignore
-            # print("[DEBUG Helper] is_jupyter_notebook: No IPython instance found.")
+            # logger.debug("is_jupyter_notebook: No IPython instance found.")
             return False
         class_name = str(ip.__class__)
-        # print(f"[DEBUG Helper] is_jupyter_notebook: IPython class name: {class_name}")
+        # logger.debug(f"is_jupyter_notebook: IPython class name: {class_name}")
         if "ZMQInteractiveShell" in class_name:
-            # print("[DEBUG Helper] is_jupyter_notebook: Jupyter detected (ZMQInteractiveShell).")
+            # logger.debug("is_jupyter_notebook: Jupyter detected (ZMQInteractiveShell).")
             return True
-        # print("[DEBUG Helper] is_jupyter_notebook: Not Jupyter (IPython instance found, but not ZMQInteractiveShell).")
+        # logger.debug("is_jupyter_notebook: Not Jupyter (IPython instance found, but not ZMQInteractiveShell).")
         return False
     except Exception as e:
-        print(
-            f"[DEBUG Helper] is_jupyter_notebook: Exception occurred: {e}"
-        )  # Reduce verbosity
+        logger.debug(
+            f"is_jupyter_notebook: Exception occurred: {e}"
+        )  # Keep as debug for less noise
         return False
 
 
@@ -99,35 +100,35 @@ def get_notebook_executed_code():
     Returns all executed code from the current notebook session.
     Returns str or None: All executed code as a string, or None if not possible.
     """
-    print("[DEBUG Helper] Attempting to get notebook execution history...")
+    logger.debug("Attempting to get notebook execution history...")
     try:
         # Fix: Import get_ipython directly
         from IPython.core.getipython import get_ipython
 
         ip = get_ipython()  # Use the imported function
         if ip is None or not hasattr(ip, "history_manager"):
-            print(
-                "[DEBUG Helper] get_notebook_executed_code: No IPython instance or history_manager."
+            logger.debug(
+                "get_notebook_executed_code: No IPython instance or history_manager."
             )
             return None
         history_manager = ip.history_manager
         # Limiting history range for debugging? Maybe get_tail(N)? For now, get all.
         # history = history_manager.get_range(start=1) # type: ignore
         history = list(history_manager.get_range(start=1))  # type: ignore # Convert to list to get length
-        print(
-            f"[DEBUG Helper] get_notebook_executed_code: Retrieved {len(history)} history entries."
+        logger.debug(
+            f"get_notebook_executed_code: Retrieved {len(history)} history entries."
         )
         source_code = ""
         separator = "\n#<NEBU_CELL_SEP>#\n"
         for _, _, content in history:  # Use _ for unused session, lineno
             if isinstance(content, str) and content.strip():
                 source_code += content + separator
-        print(
-            f"[DEBUG Helper] get_notebook_executed_code: Total history source length: {len(source_code)}"
+        logger.debug(
+            f"get_notebook_executed_code: Total history source length: {len(source_code)}"
         )
         return source_code
     except Exception as e:
-        print(f"[DEBUG Helper] get_notebook_executed_code: Error getting history: {e}")
+        logger.error(f"get_notebook_executed_code: Error getting history: {e}")
         return None
 
 
@@ -140,15 +141,15 @@ def extract_definition_source_from_string(
     Uses AST parsing for robustness.
     def_type can be ast.FunctionDef or ast.ClassDef.
     """
-    print(
-        f"[DEBUG Helper] Extracting '{def_name}' ({def_type.__name__}) from history string (len: {len(source_string)})..."
+    logger.debug(
+        f"Extracting '{def_name}' ({def_type.__name__}) from history string (len: {len(source_string)})..."
     )
     if not source_string or not def_name:
-        print("[DEBUG Helper] extract: Empty source string or def_name.")
+        logger.debug("extract: Empty source string or def_name.")
         return None
 
     cells = source_string.split("#<NEBU_CELL_SEP>#")
-    print(f"[DEBUG Helper] extract: Split history into {len(cells)} potential cells.")
+    logger.debug(f"extract: Split history into {len(cells)} potential cells.")
     last_found_source = None
 
     for i, cell in enumerate(reversed(cells)):
@@ -156,7 +157,7 @@ def extract_definition_source_from_string(
         cell = cell.strip()
         if not cell:
             continue
-        # print(f"[DEBUG Helper] extract: Analyzing cell #{cell_num}...") # Can be very verbose
+        # logger.debug(f"extract: Analyzing cell #{cell_num}...") # Can be very verbose
         try:
             tree = ast.parse(cell)
             found_in_cell = False
@@ -167,22 +168,22 @@ def extract_definition_source_from_string(
                     )  # Check if it's the right type (FuncDef or ClassDef)
                     and getattr(node, "name", None) == def_name  # Safely check name
                 ):
-                    print(
-                        f"[DEBUG Helper] extract: Found node for '{def_name}' in cell #{cell_num}."
+                    logger.debug(
+                        f"extract: Found node for '{def_name}' in cell #{cell_num}."
                     )
                     try:
                         # Use ast.get_source_segment for accurate extraction (Python 3.8+)
                         func_source = ast.get_source_segment(cell, node)
                         if func_source:
-                            print(
-                                f"[DEBUG Helper] extract: Successfully extracted source using get_source_segment for '{def_name}'."
+                            logger.debug(
+                                f"extract: Successfully extracted source using get_source_segment for '{def_name}'."
                             )
                             last_found_source = func_source
                             found_in_cell = True
                             break  # Stop searching this cell
                     except AttributeError:  # Fallback for Python < 3.8
-                        print(
-                            f"[DEBUG Helper] extract: get_source_segment failed (likely Py < 3.8), using fallback for '{def_name}'."
+                        logger.debug(
+                            f"extract: get_source_segment failed (likely Py < 3.8), using fallback for '{def_name}'."
                         )
                         start_lineno = getattr(node, "lineno", 1) - 1
                         end_lineno = getattr(node, "end_lineno", start_lineno + 1)
@@ -210,34 +211,34 @@ def extract_definition_source_from_string(
                                 .startswith(("def ", "class "))
                             ):
                                 last_found_source = "\n".join(extracted_lines)
-                                print(
-                                    f"[DEBUG Helper] extract: Extracted source via fallback for '{def_name}'."
+                                logger.debug(
+                                    f"extract: Extracted source via fallback for '{def_name}'."
                                 )
                                 found_in_cell = True
                                 break
                         else:
-                            print(
-                                f"[DEBUG Helper] extract: Warning: Line numbers out of bounds for {def_name} in cell (fallback)."
+                            logger.warning(
+                                f"extract: Line numbers out of bounds for {def_name} in cell (fallback)."
                             )
 
             if found_in_cell:
-                print(
-                    f"[DEBUG Helper] extract: Found and returning source for '{def_name}' from cell #{cell_num}."
+                logger.debug(
+                    f"extract: Found and returning source for '{def_name}' from cell #{cell_num}."
                 )
                 return last_found_source  # Found last definition, return immediately
 
         except (SyntaxError, ValueError) as e:
-            # print(f"[DEBUG Helper] extract: Skipping cell #{cell_num} due to parse error: {e}") # Can be verbose
+            # logger.debug(f"extract: Skipping cell #{cell_num} due to parse error: {e}") # Can be verbose
             continue
         except Exception as e:
-            print(
-                f"[DEBUG Helper] extract: Warning: AST processing error for {def_name} in cell #{cell_num}: {e}"
+            logger.warning(
+                f"extract: AST processing error for {def_name} in cell #{cell_num}: {e}"
             )
             continue
 
     if not last_found_source:
-        print(
-            f"[DEBUG Helper] extract: Definition '{def_name}' of type {def_type.__name__} not found in history search."
+        logger.debug(
+            f"extract: Definition '{def_name}' of type {def_type.__name__} not found in history search."
         )
     return last_found_source
 
@@ -257,13 +258,13 @@ def include(obj: Any) -> Any:
         source = dill.source.getsource(obj)
         dedented_source = textwrap.dedent(source)
         setattr(obj, _NEBU_EXPLICIT_SOURCE_ATTR, dedented_source)
-        print(
-            f"[DEBUG @include] Successfully captured source for: {getattr(obj, '__name__', str(obj))}"
+        logger.debug(
+            f"@include: Successfully captured source for: {getattr(obj, '__name__', str(obj))}"
         )
     except Exception as e:
         # Don't fail the definition, just warn
-        print(
-            f"Warning: @include could not capture source for {getattr(obj, '__name__', str(obj))}: {e}. Automatic source retrieval will be attempted later."
+        logger.warning(
+            f"@include could not capture source for {getattr(obj, '__name__', str(obj))}: {e}. Automatic source retrieval will be attempted later."
         )
     return obj
 
@@ -276,44 +277,44 @@ def get_model_source(
     Checks explicit source, then notebook history (if provided), then dill.
     """
     model_name_str = getattr(model_class, "__name__", str(model_class))
-    print(f"[DEBUG get_model_source] Getting source for: {model_name_str}")
+    logger.debug(f"get_model_source: Getting source for: {model_name_str}")
     # 1. Check explicit source
     explicit_source = getattr(model_class, _NEBU_EXPLICIT_SOURCE_ATTR, None)
     if explicit_source:
-        print(
-            f"[DEBUG get_model_source] Using explicit source (@include) for: {model_name_str}"
+        logger.debug(
+            f"get_model_source: Using explicit source (@include) for: {model_name_str}"
         )
         return explicit_source
 
     # 2. Check notebook history
     if notebook_code and hasattr(model_class, "__name__"):
-        print(
-            f"[DEBUG get_model_source] Attempting notebook history extraction for: {model_class.__name__}"
+        logger.debug(
+            f"get_model_source: Attempting notebook history extraction for: {model_class.__name__}"
         )
         extracted_source = extract_definition_source_from_string(
             notebook_code, model_class.__name__, ast.ClassDef
         )
         if extracted_source:
-            print(
-                f"[DEBUG get_model_source] Using notebook history source for: {model_class.__name__}"
+            logger.debug(
+                f"get_model_source: Using notebook history source for: {model_class.__name__}"
             )
             return extracted_source
         else:
-            print(
-                f"[DEBUG get_model_source] Notebook history extraction failed for: {model_class.__name__}. Proceeding to dill."
+            logger.debug(
+                f"get_model_source: Notebook history extraction failed for: {model_class.__name__}. Proceeding to dill."
             )
 
     # 3. Fallback to dill
     try:
-        print(
-            f"[DEBUG get_model_source] Attempting dill fallback for: {model_name_str}"
+        logger.debug(
+            f"get_model_source: Attempting dill fallback for: {model_name_str}"
         )
         source = dill.source.getsource(model_class)
-        print(f"[DEBUG get_model_source] Using dill source for: {model_name_str}")
+        logger.debug(f"get_model_source: Using dill source for: {model_name_str}")
         return textwrap.dedent(source)
     except (IOError, TypeError, OSError) as e:
-        print(
-            f"[DEBUG get_model_source] Failed dill fallback for: {model_name_str}: {e}"
+        logger.debug(
+            f"get_model_source: Failed dill fallback for: {model_name_str}: {e}"
         )
         return None
 
@@ -324,22 +325,22 @@ def get_type_source(
 ) -> Optional[Any]:
     """Get the source code for a type, including generic parameters."""
     type_obj_str = str(type_obj)
-    print(f"[DEBUG get_type_source] Getting source for type: {type_obj_str}")
+    logger.debug(f"get_type_source: Getting source for type: {type_obj_str}")
     origin = get_origin(type_obj)
     args = get_args(type_obj)
 
     if origin is not None:
         # Use updated get_model_source for origin
-        print(
-            f"[DEBUG get_type_source] Detected generic type. Origin: {origin}, Args: {args}"
+        logger.debug(
+            f"get_type_source: Detected generic type. Origin: {origin}, Args: {args}"
         )
         origin_source = get_model_source(origin, notebook_code)
         args_sources = []
 
         # Recursively get sources for all type arguments
         for arg in args:
-            print(
-                f"[DEBUG get_type_source] Recursively getting source for generic arg #{arg}"
+            logger.debug(
+                f"get_type_source: Recursively getting source for generic arg #{arg}"
             )
             arg_source = get_type_source(arg, notebook_code)
             if arg_source:
@@ -347,8 +348,8 @@ def get_type_source(
 
         # Return tuple only if origin source or some arg sources were found
         if origin_source or args_sources:
-            print(
-                f"[DEBUG get_type_source] Returning tuple source for generic: {type_obj_str}"
+            logger.debug(
+                f"get_type_source: Returning tuple source for generic: {type_obj_str}"
             )
             return (origin_source, args_sources)
 
@@ -356,12 +357,12 @@ def get_type_source(
     # Try get_model_source as a last resort for unknown types
     fallback_source = get_model_source(type_obj, notebook_code)
     if fallback_source:
-        print(
-            f"[DEBUG get_type_source] Using fallback get_model_source for: {type_obj_str}"
+        logger.debug(
+            f"get_type_source: Using fallback get_model_source for: {type_obj_str}"
         )
         return fallback_source
 
-    print(f"[DEBUG get_type_source] Failed to get source for: {type_obj_str}")
+    logger.debug(f"get_type_source: Failed to get source for: {type_obj_str}")
     return None
 
 
@@ -392,20 +393,22 @@ def processor(
     health_check: Optional[V1ContainerHealthCheck] = None,
     execution_mode: str = "inline",
     config: Optional[GlobalConfig] = None,
+    hot_reload: bool = True,
+    debug: bool = False,
 ):
     def decorator(
         func: Callable[[Any], Any],
     ) -> Processor:
         # --- Prevent Recursion Guard ---
         if os.environ.get(_NEBU_INSIDE_CONSUMER_ENV_VAR) == "1":
-            print(
-                f"[DEBUG Decorator] Guard triggered for '{func.__name__}'. Returning original function."
+            logger.debug(
+                f"Decorator Guard triggered for '{func.__name__}'. Returning original function."
             )
             return func  # type: ignore
         # --- End Guard ---
 
-        print(
-            f"[DEBUG Decorator Init] @processor decorating function '{func.__name__}'"
+        logger.debug(
+            f"Decorator Init: @processor decorating function '{func.__name__}'"
         )
         all_env = env or []
         processor_name = func.__name__
@@ -415,7 +418,7 @@ def processor(
         effective_config = config
 
         # --- Get Decorated Function File Path and Directory ---
-        print("[DEBUG Decorator] Getting source file path for decorated function...")
+        logger.debug("Decorator: Getting source file path for decorated function...")
         func_file_path: Optional[str] = None
         func_dir: Optional[str] = None
         rel_func_path: Optional[str] = None  # Relative path within func_dir
@@ -426,9 +429,9 @@ def processor(
             func_dir = os.path.dirname(func_file_path)
             # Calculate relative path based on the resolved directory
             rel_func_path = os.path.relpath(func_file_path, func_dir)
-            print(f"[DEBUG Decorator] Found real file path: {func_file_path}")
-            print(f"[DEBUG Decorator] Found function directory: {func_dir}")
-            print(f"[DEBUG Decorator] Relative function path: {rel_func_path}")
+            logger.debug(f"Decorator: Found real file path: {func_file_path}")
+            logger.debug(f"Decorator: Found function directory: {func_dir}")
+            logger.debug(f"Decorator: Relative function path: {rel_func_path}")
         except (TypeError, OSError) as e:
             # TypeError can happen if func is not a module, class, method, function, traceback, frame, or code object
             raise ValueError(
@@ -447,7 +450,7 @@ def processor(
                 "Could not determine function directory or relative path for S3 upload."
             )
         # --- Get API Key ---
-        print("[DEBUG Decorator] Loading Nebu configuration...")
+        logger.debug("Decorator: Loading Nebu configuration...")
         try:
             if not effective_config:
                 effective_config = GlobalConfig.read()
@@ -455,7 +458,7 @@ def processor(
             if not current_server or not current_server.api_key:
                 raise ValueError("Nebu server configuration or API key not found.")
             api_key = current_server.api_key
-            print("[DEBUG Decorator] Nebu API key loaded successfully.")
+            logger.debug("Decorator: Nebu API key loaded successfully.")
 
             # # Add additional environment variables from current configuration
             # all_env.append(V1EnvVar(key="AGENTSEA_API_KEY", value=api_key))
@@ -480,10 +483,10 @@ def processor(
             # if orign_server:
             #     all_env.append(V1EnvVar(key="ORIGN_SERVER", value=orign_server))
             # else:
-            #     print("[DEBUG Decorator] No Orign server found. Not setting...")
+            #     logger.debug("Decorator: No Orign server found. Not setting...")
 
         except Exception as e:
-            print(f"ERROR: Failed to load Nebu configuration or API key: {e}")
+            logger.error(f"Failed to load Nebu configuration or API key: {e}")
             raise RuntimeError(
                 f"Failed to load Nebu configuration or API key: {e}"
             ) from e
@@ -492,19 +495,19 @@ def processor(
         # --- Determine Namespace ---
         effective_namespace = namespace  # Start with the provided namespace
         if effective_namespace is None:
-            print("[DEBUG Decorator] Namespace not provided, fetching user profile...")
+            logger.debug("Decorator: Namespace not provided, fetching user profile...")
             try:
                 user_profile = get_user_profile(api_key)
                 if user_profile.handle:
                     effective_namespace = user_profile.handle
-                    print(
-                        f"[DEBUG Decorator] Using user handle '{effective_namespace}' as namespace."
+                    logger.debug(
+                        f"Decorator: Using user handle '{effective_namespace}' as namespace."
                     )
                 else:
                     raise ValueError("User profile does not contain a handle.")
             except Exception as e:
-                print(
-                    f"ERROR: Failed to get user profile or handle for default namespace: {e}"
+                logger.error(
+                    f"Failed to get user profile or handle for default namespace: {e}"
                 )
                 raise RuntimeError(
                     f"Failed to get user profile or handle for default namespace: {e}"
@@ -513,7 +516,7 @@ def processor(
 
         # Use processor_name instead of name
         S3_TOKEN_ENDPOINT = f"{NEBU_API_BASE_URL}/v1/auth/temp-s3-tokens/{effective_namespace}/{processor_name}"
-        print(f"[DEBUG Decorator] Fetching S3 token from: {S3_TOKEN_ENDPOINT}")
+        logger.debug(f"Decorator: Fetching S3 token from: {S3_TOKEN_ENDPOINT}")
         try:
             headers = {"Authorization": f"Bearer {api_key}"}  # Add headers here
 
@@ -522,7 +525,7 @@ def processor(
             response.raise_for_status()  # Raise HTTPError for bad responses (4xx or 5xx)
             s3_token_data = response.json()
 
-            print(f"[DEBUG Decorator] S3 token data: {s3_token_data}")
+            logger.debug(f"Decorator: S3 token data: {s3_token_data}")
 
             aws_access_key_id = s3_token_data.get("access_key_id")
             aws_secret_access_key = s3_token_data.get("secret_access_key")
@@ -558,8 +561,8 @@ def processor(
             )  # Ensure trailing slash for prefix
             s3_destination_uri = f"s3://{parsed_base.netloc}/{s3_destination_key}"
 
-            print(
-                f"[DEBUG Decorator] Uploading code from '{func_dir}' to '{s3_destination_uri}'"
+            logger.debug(
+                f"Decorator: Uploading code from '{func_dir}' to '{s3_destination_uri}'"
             )
 
             # Instantiate Bucket with temporary credentials
@@ -583,48 +586,46 @@ def processor(
                 delete=True,
                 dry_run=False,
             )
-            print("[DEBUG Decorator] S3 code upload completed.")
+            logger.debug("Decorator: S3 code upload completed.")
 
         except requests.exceptions.RequestException as e:
-            print(f"ERROR: Failed to fetch S3 token from {S3_TOKEN_ENDPOINT}: {e}")
+            logger.error(f"Failed to fetch S3 token from {S3_TOKEN_ENDPOINT}: {e}")
             raise RuntimeError(
                 f"Failed to fetch S3 token from {S3_TOKEN_ENDPOINT}: {e}"
             ) from e
         except ClientError as e:
-            print(f"ERROR: Failed to upload code to S3 {s3_destination_uri}: {e}")
+            logger.error(f"Failed to upload code to S3 {s3_destination_uri}: {e}")
             # Attempt to provide more context from the error if possible
             error_code = e.response.get("Error", {}).get("Code")
             error_msg = e.response.get("Error", {}).get("Message")
-            print(f"      S3 Error Code: {error_code}, Message: {error_msg}")
+            logger.error(f"      S3 Error Code: {error_code}, Message: {error_msg}")
             raise RuntimeError(
                 f"Failed to upload code to {s3_destination_uri}: {e}"
             ) from e
         except ValueError as e:  # Catch ValueErrors from validation
-            print(f"ERROR: Configuration or response data error: {e}")
+            logger.error(f"Configuration or response data error: {e}")
             raise RuntimeError(f"Configuration or response data error: {e}") from e
         except Exception as e:
-            print(f"ERROR: Unexpected error during S3 token fetch or upload: {e}")
+            logger.exception(f"Unexpected error during S3 token fetch or upload: {e}")
             # Consider logging traceback here for better debugging
             import traceback
 
-            traceback.print_exc()
+            traceback.print_exc()  # Keep this explicit traceback for now in case logging isn't configured yet
             raise RuntimeError(f"Unexpected error during S3 setup: {e}") from e
 
         # --- Process Manually Included Objects (Keep for now, add source via env) ---
-        # This part remains unchanged for now, using @include and environment variables.
-        # Future: Could potentially upload these to S3 as well if they become large.
         included_sources: Dict[Any, Any] = {}
         notebook_code_for_include = None  # Get notebook code only if needed for include
         if include:
             # Determine if we are in Jupyter only if needed for include fallback
-            # print("[DEBUG Decorator] Processing manually included objects...")
+            # logger.debug("Decorator: Processing manually included objects...")
             is_jupyter_env = is_jupyter_notebook()
             if is_jupyter_env:
                 notebook_code_for_include = get_notebook_executed_code()
 
             for i, obj in enumerate(include):
                 obj_name_str = getattr(obj, "__name__", str(obj))
-                # print(f"[DEBUG Decorator] Getting source for manually included object: {obj_name_str}")
+                # logger.debug(f"Decorator: Getting source for manually included object: {obj_name_str}")
                 # Pass notebook code only if available and needed by get_model_source
                 obj_source = get_model_source(
                     obj, notebook_code_for_include if is_jupyter_env else None
@@ -633,27 +634,29 @@ def processor(
                     included_sources[obj] = obj_source
                     # Decide how to pass included source - keep using Env Vars for now
                     env_key_base = f"INCLUDED_OBJECT_{i}"
-                    if isinstance(obj_source, str):  # type: ignore[arg-type]
+                    # Correct check for string type - Linter might complain but it's safer
+                    if isinstance(obj_source, str):  # type: ignore
                         all_env.append(
                             V1EnvVar(key=f"{env_key_base}_SOURCE", value=obj_source)
                         )
-                        # print(f"[DEBUG Decorator] Added string source to env for included obj: {obj_name_str}")
+                        # logger.debug(f"Decorator: Added string source to env for included obj: {obj_name_str}")
                     elif isinstance(obj_source, tuple):
                         # Handle tuple source (origin, args) - assumes get_model_source/get_type_source logic
                         # Ensure obj_source is indeed a tuple before unpacking
                         if len(obj_source) == 2:
                             # Now safe to unpack
-                            origin_src, arg_srcs = obj_source  # type: ignore[misc] # Suppress persistent tuple unpacking error
-                            # type: ignore[misc] # Suppress persistent tuple unpacking error
+                            origin_src, arg_srcs = obj_source  # type: ignore
                             if origin_src and isinstance(origin_src, str):
                                 all_env.append(
                                     V1EnvVar(
                                         key=f"{env_key_base}_SOURCE", value=origin_src
                                     )
                                 )
-                            # Handle arg_srcs (this part seems okay)
+                            # Handle arg_srcs - ensure it's iterable (list)
+                            # Linter complains about "Never" not iterable, check type explicitly
                             if isinstance(arg_srcs, list):
                                 for j, arg_src in enumerate(arg_srcs):
+                                    # Ensure arg_src is string before adding
                                     if isinstance(arg_src, str):
                                         all_env.append(
                                             V1EnvVar(
@@ -662,29 +665,27 @@ def processor(
                                             )
                                         )
                             else:
-                                print(
-                                    f"[DEBUG Decorator] Warning: Expected arg_srcs to be a list, got {type(arg_srcs)}"
+                                logger.warning(
+                                    f"Decorator: Expected arg_srcs to be a list, got {type(arg_srcs)}"
                                 )
                         else:
                             # Handle unexpected type or structure for obj_source if necessary
-                            # For now, assume it fits the expected tuple structure if isinstance passes
-                            # origin_src, arg_srcs = None, [] # Default/error state (already covered by outer check)
-                            print(
-                                f"[DEBUG Decorator] Warning: Unexpected obj_source structure: {obj_source}"
+                            logger.warning(
+                                f"Decorator: Unexpected obj_source structure: {obj_source}"
                             )
                     else:
-                        print(
-                            f"Warning: Unknown source type for included object {obj_name_str}: {type(obj_source)}"
+                        logger.warning(
+                            f"Unknown source type for included object {obj_name_str}: {type(obj_source)}"
                         )
                 else:
-                    print(
-                        f"Warning: Could not retrieve source for manually included object: {obj_name_str}. It might not be available in the consumer."
+                    logger.warning(
+                        f"Could not retrieve source for manually included object: {obj_name_str}. It might not be available in the consumer."
                     )
         # --- End Manually Included Objects ---
 
         # --- Validate Function Signature and Types (Keep as is) ---
-        print(
-            f"[DEBUG Decorator] Validating signature and type hints for {processor_name}..."
+        logger.debug(
+            f"Decorator: Validating signature and type hints for {processor_name}..."
         )
         sig = inspect.signature(func)
         params = list(sig.parameters.values())
@@ -696,17 +697,17 @@ def processor(
         try:
             # Attempt to resolve type hints
             type_hints = get_type_hints(func, globalns=func.__globals__, localns=None)
-            print(f"[DEBUG Decorator] Resolved type hints: {type_hints}")
+            logger.debug(f"Decorator: Resolved type hints: {type_hints}")
         except NameError as e:
             # Specific handling for NameError (common in notebooks/dynamic environments)
-            print(
-                f"Warning: Could not fully resolve type hints for {processor_name} due to NameError: {e}. Type validation might be incomplete."
+            logger.warning(
+                f"Could not fully resolve type hints for {processor_name} due to NameError: {e}. Type validation might be incomplete."
             )
             # Try to get raw annotations as fallback?
             type_hints = getattr(func, "__annotations__", {})
-            print(f"[DEBUG Decorator] Using raw annotations as fallback: {type_hints}")
+            logger.debug(f"Decorator: Using raw annotations as fallback: {type_hints}")
         except Exception as e:
-            print(f"[DEBUG Decorator] Error getting type hints: {e}")
+            logger.error(f"Decorator: Error getting type hints: {e}")
             # Potentially re-raise or handle based on severity
             raise TypeError(
                 f"Could not evaluate type hints for {processor_name}: {e}. Ensure all type dependencies are defined or imported."
@@ -722,22 +723,22 @@ def processor(
             param_name
         )  # Use .get for safety with raw annotations fallback
         param_type_str_repr = str(param_type)  # Use string representation
-        print(
-            f"[DEBUG Decorator] Parameter '{param_name}' type hint: {param_type_str_repr}"
+        logger.debug(
+            f"Decorator: Parameter '{param_name}' type hint: {param_type_str_repr}"
         )
 
         return_type = type_hints.get("return")
         return_type_str_repr = str(return_type)
-        print(f"[DEBUG Decorator] Return type hint: {return_type_str_repr}")
+        logger.debug(f"Decorator: Return type hint: {return_type_str_repr}")
 
         # --- Determine Input Type (StreamMessage, ContentType) ---
         # This logic remains mostly the same, using the resolved types
-        print(
-            f"[DEBUG Decorator] Determining input type structure for param type hint: {param_type_str_repr}"
+        logger.debug(
+            f"Decorator: Determining input type structure for param type hint: {param_type_str_repr}"
         )
         origin = get_origin(param_type) if param_type else None
         args = get_args(param_type) if param_type else tuple()
-        print(f"[DEBUG Decorator] get_origin result: {origin}, get_args result: {args}")
+        logger.debug(f"Decorator: get_origin result: {origin}, get_args result: {args}")
         is_stream_message = False
         content_type = None
         content_type_name_from_regex = None  # Store regex result here
@@ -749,96 +750,96 @@ def processor(
         if origin is message_cls or (
             isinstance(origin, type) and origin is message_cls
         ):
-            print(
-                "[DEBUG Decorator] Input type identified as Message via get_origin/isinstance."
+            logger.debug(
+                "Decorator: Input type identified as Message via get_origin/isinstance."
             )
             is_stream_message = True
             if args:
                 content_type = args[0]
-                print(
-                    f"[DEBUG Decorator] Content type extracted via get_args: {content_type}"
+                logger.debug(
+                    f"Decorator: Content type extracted via get_args: {content_type}"
                 )
             else:
-                print(
-                    "[DEBUG Decorator] Message detected, but no generic arguments found via get_args. Attempting regex fallback on string repr."
+                logger.debug(
+                    "Decorator: Message detected, but no generic arguments found via get_args. Attempting regex fallback on string repr."
                 )
                 # --- Regex Fallback Start ---
                 match = re.search(r"Message\[([\w\.]+)\]", param_type_str_repr)
                 if match:
                     content_type_name_from_regex = match.group(1)
-                    print(
-                        f"[DEBUG Decorator] Extracted content type name via regex: {content_type_name_from_regex}"
+                    logger.debug(
+                        f"Decorator: Extracted content type name via regex: {content_type_name_from_regex}"
                     )
                 else:
-                    print(
-                        "[DEBUG Decorator] Regex fallback failed to extract content type name."
+                    logger.debug(
+                        "Decorator: Regex fallback failed to extract content type name."
                     )
                 # --- Regex Fallback End ---
         # Check 2a: Regex fallback if get_origin failed but string matches pattern
         elif origin is None and param_type is not None:
-            print(
-                "[DEBUG Decorator] get_origin failed. Attempting regex fallback on string representation."
+            logger.debug(
+                "Decorator: get_origin failed. Attempting regex fallback on string representation."
             )
             match = re.search(r"Message\[([\w\.]+)\]", param_type_str_repr)
             if match:
-                print(
-                    "[DEBUG Decorator] Regex fallback successful after get_origin failed."
+                logger.debug(
+                    "Decorator: Regex fallback successful after get_origin failed."
                 )
                 is_stream_message = True
                 content_type_name_from_regex = match.group(1)
                 # We don't have the actual content_type object here, only the name
                 content_type = None
-                print(
-                    f"[DEBUG Decorator] Extracted content type name via regex: {content_type_name_from_regex}"
+                logger.debug(
+                    f"Decorator: Extracted content type name via regex: {content_type_name_from_regex}"
                 )
             else:
-                print(
-                    "[DEBUG Decorator] Regex fallback also failed. Treating as non-Message type."
+                logger.debug(
+                    "Decorator: Regex fallback also failed. Treating as non-Message type."
                 )
                 is_stream_message = False
                 content_type = None
         # Check 2: Direct type check (Handles cases where get_origin might fail but type is correct)
         elif isinstance(param_type, type) and param_type is message_cls:
             # This case likely won't have generic args accessible easily if get_origin failed
-            print(
-                "[DEBUG Decorator] Input type identified as direct Message type. Attempting regex fallback."
+            logger.debug(
+                "Decorator: Input type identified as direct Message type. Attempting regex fallback."
             )
             is_stream_message = True
             # --- Regex Fallback Start ---
             match = re.search(r"Message\[([\w\.]+)\]", param_type_str_repr)
             if match:
                 content_type_name_from_regex = match.group(1)
-                print(
-                    f"[DEBUG Decorator] Extracted content type name via regex: {content_type_name_from_regex}"
+                logger.debug(
+                    f"Decorator: Extracted content type name via regex: {content_type_name_from_regex}"
                 )
             else:
-                print(
-                    "[DEBUG Decorator] Regex fallback failed to extract content type name."
+                logger.debug(
+                    "Decorator: Regex fallback failed to extract content type name."
                 )
             # --- Regex Fallback End ---
         # Check 3: Removed old placeholder elif branch
 
         else:  # Handle cases where param_type might be None or origin is something else
-            print(
-                f"[DEBUG Decorator] Input parameter '{param_name}' type ({param_type_str_repr}) identified as non-Message type."
+            logger.debug(
+                f"Decorator: Input parameter '{param_name}' type ({param_type_str_repr}) identified as non-Message type."
             )
 
-        print(
-            f"[DEBUG Decorator] Final Input Type Determination: is_stream_message={is_stream_message}, content_type={content_type}"
+        logger.debug(
+            f"Decorator: Final Input Type Determination: is_stream_message={is_stream_message}, content_type={content_type}"
         )
         # --- End Input Type Determination ---
 
         # --- Validate Types are BaseModel ---
-        print(
-            "[DEBUG Decorator] Validating parameter and return types are BaseModel subclasses..."
+        logger.debug(
+            "Decorator: Validating parameter and return types are BaseModel subclasses..."
         )
 
         # Define check_basemodel locally or ensure it's available
         def check_basemodel(type_to_check: Optional[Any], desc: str):
-            # print(f"[DEBUG Decorator] check_basemodel: Checking {desc} - Type: {type_to_check}") # Verbose
+            # logger.debug(f"Decorator check_basemodel: Checking {desc} - Type: {type_to_check}") # Verbose
             if type_to_check is None or type_to_check is Any:
-                print(
-                    f"[DEBUG Decorator] check_basemodel: Skipping check for {desc} (type is None or Any)."
+                logger.debug(
+                    f"Decorator check_basemodel: Skipping check for {desc} (type is None or Any)."
                 )
                 return
             # Handle Optional[T] by getting the inner type
@@ -852,11 +853,11 @@ def processor(
                 non_none_args = [arg for arg in type_args if arg is not type(None)]
                 if len(non_none_args) == 1:
                     actual_type = non_none_args[0]
-                    # print(f"[DEBUG Decorator] check_basemodel: Unwrapped Optional/Union to {actual_type} for {desc}")
+                    # logger.debug(f"Decorator check_basemodel: Unwrapped Optional/Union to {actual_type} for {desc}")
                 else:
                     # Handle complex Unions later if needed, skip check for now
-                    print(
-                        f"[DEBUG Decorator] check_basemodel: Skipping check for complex Union {desc}: {type_to_check}"
+                    logger.debug(
+                        f"Decorator check_basemodel: Skipping check for complex Union {desc}: {type_to_check}"
                     )
                     return
 
@@ -864,7 +865,7 @@ def processor(
             effective_type = (
                 get_origin(actual_type) or actual_type
             )  # Handle generics like List[Model]
-            # print(f"[DEBUG Decorator] check_basemodel: Effective type for {desc}: {effective_type}") # Verbose
+            # logger.debug(f"Decorator check_basemodel: Effective type for {desc}: {effective_type}") # Verbose
             if isinstance(effective_type, type) and not issubclass(
                 effective_type, BaseModel
             ):
@@ -879,26 +880,26 @@ def processor(
                     type(None),
                 )
                 if effective_type not in allowed_non_model_types:
-                    print(
-                        f"[DEBUG Decorator] check_basemodel: Error - {desc} effective type ({effective_type.__name__}) is not BaseModel or standard type."
+                    logger.error(
+                        f"Decorator check_basemodel: Error - {desc} effective type ({effective_type.__name__}) is not BaseModel or standard type."
                     )
                     raise TypeError(
                         f"{desc} effective type ({effective_type.__name__}) must be BaseModel subclass or standard type (str, int, etc.)"
                     )
                 else:
-                    print(
-                        f"[DEBUG Decorator] check_basemodel: OK - {desc} is standard type {effective_type.__name__}."
+                    logger.debug(
+                        f"Decorator check_basemodel: OK - {desc} is standard type {effective_type.__name__}."
                     )
 
             elif not isinstance(effective_type, type):
                 # Allow TypeVars or other constructs for now? Or enforce BaseModel? Enforce for now.
-                print(
-                    f"[DEBUG Decorator] check_basemodel: Warning - {desc} effective type '{effective_type}' is not a class. Cannot verify BaseModel subclass."
+                logger.warning(
+                    f"Decorator check_basemodel: Warning - {desc} effective type '{effective_type}' is not a class. Cannot verify BaseModel subclass."
                 )
                 # Revisit this if TypeVars bound to BaseModel are needed.
             else:
-                print(
-                    f"[DEBUG Decorator] check_basemodel: OK - {desc} effective type ({effective_type.__name__}) is a BaseModel subclass."
+                logger.debug(
+                    f"Decorator check_basemodel: OK - {desc} effective type ({effective_type.__name__}) is a BaseModel subclass."
                 )
 
         effective_param_type = (
@@ -912,7 +913,7 @@ def processor(
         if effective_param_type is not message_cls:
             check_basemodel(effective_param_type, f"Parameter '{param_name}'")
         check_basemodel(return_type, "Return value")
-        print("[DEBUG Decorator] Type validation complete.")
+        logger.debug("Decorator: Type validation complete.")
         # --- End Type Validation ---
 
         # --- Validate Execution Mode ---
@@ -920,11 +921,11 @@ def processor(
             raise ValueError(
                 f"Invalid execution_mode: '{execution_mode}'. Must be 'inline' or 'subprocess'."
             )
-        print(f"[DEBUG Decorator] Using execution mode: {execution_mode}")
+        logger.debug(f"Decorator: Using execution mode: {execution_mode}")
         # --- End Execution Mode Validation ---
 
         # --- Populate Environment Variables ---
-        print("[DEBUG Decorator] Populating environment variables...")
+        logger.debug("Decorator: Populating environment variables...")
         # Keep: FUNCTION_NAME, PARAM_TYPE_STR, RETURN_TYPE_STR, IS_STREAM_MESSAGE, CONTENT_TYPE_NAME, MODULE_NAME
         # Add: NEBU_ENTRYPOINT_MODULE_PATH
         # Add: Included object sources (if any)
@@ -944,15 +945,15 @@ def processor(
                 calculated_module_path = ".".join(module_path_parts)
             else:
                 # Not a python file? Should not happen based on inspect.getfile
-                print(
-                    f"[DEBUG Decorator] Warning: Function source file is not a .py file: {rel_func_path}"
+                logger.warning(
+                    f"Decorator: Function source file is not a .py file: {rel_func_path}"
                 )
                 # Set calculated_module_path to None explicitly to trigger fallback later
                 calculated_module_path = None
         else:
             # Should have errored earlier if rel_func_path is None
-            print(
-                "[DEBUG Decorator] Warning: Could not determine relative function path. Falling back to func.__module__."
+            logger.warning(
+                "Decorator: Could not determine relative function path. Falling back to func.__module__."
             )
             # Set calculated_module_path to None explicitly to trigger fallback later
             calculated_module_path = None
@@ -960,10 +961,10 @@ def processor(
         # Assign final module_path using fallback if calculation failed or wasn't applicable
         if calculated_module_path is not None:
             module_path = calculated_module_path
-            print(f"[DEBUG Decorator] Using calculated module path: {module_path}")
+            logger.debug(f"Decorator: Using calculated module path: {module_path}")
         else:
             module_path = func.__module__  # Fallback
-            print(f"[DEBUG Decorator] Falling back to func.__module__: {module_path}")
+            logger.debug(f"Decorator: Falling back to func.__module__: {module_path}")
 
         # Basic info needed by consumer to find and run the function
         all_env.append(V1EnvVar(key="FUNCTION_NAME", value=processor_name))
@@ -972,8 +973,8 @@ def processor(
             all_env.append(
                 V1EnvVar(key="NEBU_ENTRYPOINT_MODULE_PATH", value=rel_func_path)
             )
-            print(
-                f"[DEBUG Decorator] Set NEBU_ENTRYPOINT_MODULE_PATH to: {rel_func_path}"
+            logger.debug(
+                f"Decorator: Set NEBU_ENTRYPOINT_MODULE_PATH to: {rel_func_path}"
             )
         # No else needed, handled by fallback calculation above
 
@@ -986,7 +987,7 @@ def processor(
                     f"init_func '{init_func_name}' must take zero parameters"
                 )
             all_env.append(V1EnvVar(key="INIT_FUNC_NAME", value=init_func_name))
-            print(f"[DEBUG Decorator] Set INIT_FUNC_NAME to: {init_func_name}")
+            logger.debug(f"Decorator: Set INIT_FUNC_NAME to: {init_func_name}")
 
         # Type info (still useful for deserialization/validation in consumer)
         # Adjust type strings to replace '__main__' with the calculated module path
@@ -998,8 +999,8 @@ def processor(
             param_type_str_repr = param_type_str_repr.replace(
                 "__main__.", f"{module_path}."
             )
-            print(
-                f"[DEBUG Decorator] Adjusted param type string: {param_type_str_repr}"
+            logger.debug(
+                f"Decorator: Adjusted param type string: {param_type_str_repr}"
             )
 
         all_env.append(V1EnvVar(key="PARAM_TYPE_STR", value=param_type_str_repr))
@@ -1009,8 +1010,8 @@ def processor(
             return_type_str_repr = return_type_str_repr.replace(
                 "__main__.", f"{module_path}."
             )
-            print(
-                f"[DEBUG Decorator] Adjusted return type string: {return_type_str_repr}"
+            logger.debug(
+                f"Decorator: Adjusted return type string: {return_type_str_repr}"
             )
 
         all_env.append(V1EnvVar(key="RETURN_TYPE_STR", value=return_type_str_repr))
@@ -1020,19 +1021,19 @@ def processor(
         content_type_name_to_set = None
         if content_type and isinstance(content_type, type):
             content_type_name_to_set = content_type.__name__
-            print(
-                f"[DEBUG Decorator] Using content type name from resolved type object: {content_type_name_to_set}"
+            logger.debug(
+                f"Decorator: Using content type name from resolved type object: {content_type_name_to_set}"
             )
         elif content_type_name_from_regex:
             content_type_name_to_set = content_type_name_from_regex
-            print(
-                f"[DEBUG Decorator] Using content type name from regex fallback: {content_type_name_to_set}"
+            logger.debug(
+                f"Decorator: Using content type name from regex fallback: {content_type_name_to_set}"
             )
         else:
             # Only warn if it was supposed to be a Message type
             if is_stream_message:
-                print(
-                    f"Warning: Could not determine CONTENT_TYPE_NAME for Message parameter {param_name} ({param_type_str_repr}). Consumer might use raw content."
+                logger.warning(
+                    f"Could not determine CONTENT_TYPE_NAME for Message parameter {param_name} ({param_type_str_repr}). Consumer might use raw content."
                 )
 
         if content_type_name_to_set:
@@ -1046,11 +1047,33 @@ def processor(
                 key="MODULE_NAME", value=module_path
             )  # module_path is guaranteed to be a string here (calculated or fallback)
         )
-        print(f"[DEBUG Decorator] Set MODULE_NAME to: {module_path}")
+        logger.debug(f"Decorator: Set MODULE_NAME to: {module_path}")
 
         # Add Execution Mode
         all_env.append(V1EnvVar(key="NEBU_EXECUTION_MODE", value=execution_mode))
-        print(f"[DEBUG Decorator] Set NEBU_EXECUTION_MODE to: {execution_mode}")
+        logger.debug(f"Decorator: Set NEBU_EXECUTION_MODE to: {execution_mode}")
+
+        # Add Hot Reload Configuration
+        if not hot_reload:
+            all_env.append(V1EnvVar(key="NEBU_DISABLE_HOT_RELOAD", value="1"))
+            logger.debug(
+                "Decorator: Set NEBU_DISABLE_HOT_RELOAD to: 1 (Hot reload disabled)"
+            )
+        else:
+            # Ensure it's explicitly '0' or unset if enabled (consumer defaults to enabled if var missing)
+            # Setting to "0" might be clearer than removing it if it was added by other means.
+            # Check if it exists and update, otherwise add "0"
+            existing_hot_reload_var = next(
+                (var for var in all_env if var.key == "NEBU_DISABLE_HOT_RELOAD"), None
+            )
+            if existing_hot_reload_var:
+                existing_hot_reload_var.value = "0"
+            else:
+                # Not strictly needed as consumer defaults to enabled, but explicit is good.
+                all_env.append(V1EnvVar(key="NEBU_DISABLE_HOT_RELOAD", value="0"))
+            logger.debug(
+                "Decorator: Hot reload enabled (NEBU_DISABLE_HOT_RELOAD=0 or unset)"
+            )
 
         # Add PYTHONPATH
         pythonpath_value = CONTAINER_CODE_DIR
@@ -1068,15 +1091,15 @@ def processor(
                 existing_pythonpath.value = pythonpath_value
         else:
             all_env.append(V1EnvVar(key="PYTHONPATH", value=pythonpath_value))
-        print(f"[DEBUG Decorator] Ensured PYTHONPATH includes: {pythonpath_value}")
+        logger.debug(f"Decorator: Ensured PYTHONPATH includes: {pythonpath_value}")
 
-        print("[DEBUG Decorator] Finished populating environment variables.")
+        logger.debug("Decorator: Finished populating environment variables.")
         # --- End Environment Variables ---
 
         # --- Add S3 Sync Volume ---
         if s3_destination_uri:
-            print(
-                f"[DEBUG Decorator] Adding volume to sync S3 code from {s3_destination_uri} to {CONTAINER_CODE_DIR}"
+            logger.debug(
+                f"Decorator: Adding volume to sync S3 code from {s3_destination_uri} to {CONTAINER_CODE_DIR}"
             )
             s3_sync_volume = V1VolumePath(
                 source=s3_destination_uri,
@@ -1091,8 +1114,8 @@ def processor(
             ):
                 all_volumes.append(s3_sync_volume)
             else:
-                print(
-                    f"[DEBUG Decorator] Volume for {s3_destination_uri} to {CONTAINER_CODE_DIR} already exists."
+                logger.debug(
+                    f"Decorator: Volume for {s3_destination_uri} to {CONTAINER_CODE_DIR} already exists."
                 )
         else:
             # Should have errored earlier if S3 upload failed
@@ -1102,7 +1125,7 @@ def processor(
         # --- End S3 Sync Volume ---
 
         # --- Final Setup ---
-        print("[DEBUG Decorator] Preparing final Processor object...")
+        logger.debug("Decorator: Preparing final Processor object...")
         metadata = V1ResourceMetaRequest(
             name=processor_name, namespace=effective_namespace, labels=labels
         )
@@ -1122,16 +1145,19 @@ def processor(
         setup_commands_list = [base_deps_install]
 
         if setup_script:
-            print("[DEBUG Decorator] Adding user setup script to setup commands.")
+            logger.debug("Decorator: Adding user setup script to setup commands.")
             setup_commands_list.append(setup_script.strip())
 
+        if debug:
+            all_env.append(V1EnvVar(key="PYTHON_LOG", value="DEBUG"))
+
         # Combine setup commands and the final execution command
         all_commands = setup_commands_list + [consumer_execution_command]
         # Use newline separator for clarity in logs and script execution
         final_command = "\n".join(all_commands)
 
-        print(
-            f"[DEBUG Decorator] Final container command:\n-------\n{final_command}\n-------"
+        logger.debug(
+            f"Decorator: Final container command:\n-------\n{final_command}\n-------"
         )
 
         container_request = V1ContainerRequest(
@@ -1154,16 +1180,16 @@ def processor(
             proxy_port=proxy_port,
             health_check=health_check,
         )
-        print("[DEBUG Decorator] Final Container Request Env Vars (Summary):")
+        logger.debug("Decorator: Final Container Request Env Vars (Summary):")
         for env_var in all_env:
             # Avoid printing potentially large included source code
             value_str = env_var.value or ""
             if "SOURCE" in env_var.key and len(value_str) > 100:
-                print(
-                    f"[DEBUG Decorator]  {env_var.key}: <source code present, length={len(value_str)}>"
+                logger.debug(
+                    f"  {env_var.key}: <source code present, length={len(value_str)}>"
                 )
             else:
-                print(f"[DEBUG Decorator]  {env_var.key}: {value_str}")
+                logger.debug(f"  {env_var.key}: {value_str}")
 
         processor_instance = Processor(
             name=processor_name,
@@ -1177,19 +1203,19 @@ def processor(
             scale_config=scale,
             no_delete=no_delete,
         )
-        print(
-            f"[DEBUG Decorator] Processor instance '{processor_name}' created successfully."
+        logger.debug(
+            f"Decorator: Processor instance '{processor_name}' created successfully."
         )
         # Store original func for potential local invocation/testing? Keep for now.
         # TODO: Add original_func to Processor model definition if this is desired
-        # setattr(processor_instance, 'original_func', func) # Use setattr if not in model
-        try:
-            # This will fail if Processor hasn't been updated to include this field
-            processor_instance.original_func = func  # type: ignore
-        except AttributeError:
-            print(
-                "Warning: Could not assign original_func to Processor instance. Update Processor model or remove assignment."
-            )
+        # Commenting out as Processor model does not have this field
+        # try:
+        #     # This will fail if Processor hasn't been updated to include this field
+        #     processor_instance.original_func = func  # type: ignore
+        # except AttributeError:
+        #     logger.warning(
+        #         "Could not assign original_func to Processor instance. Update Processor model or remove assignment."
+        #     )
 
         return processor_instance