nebu 0.1.51__tar.gz → 0.1.53__tar.gz

{nebu-0.1.51/src/nebu.egg-info → nebu-0.1.53}/PKG-INFO

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

{nebu-0.1.51 → nebu-0.1.53}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nebu"
-version = "0.1.51"
+version = "0.1.53"
 description = "A globally distributed container runtime"
 readme = "README.md"
 requires-python = ">=3.10.14"

{nebu-0.1.51 → nebu-0.1.53}/src/nebu/processors/consumer.py

@@ -6,7 +6,7 @@ import socket
 import sys
 import time
 import traceback
-import types  # Added for ModuleType
+import types
 from datetime import datetime, timezone
 from typing import Any, Callable, Dict, List, Optional, Tuple, TypeVar, cast
 
@@ -350,7 +350,9 @@ def process_message(message_id: str, message_data: Dict[str, str]) -> None:
     user_id = None
     try:
         payload_str = message_data.get("data")
-        if not payload_str or not isinstance(payload_str, str):
+        if (
+            not payload_str
+        ):  # Covers None and empty string, isinstance check is redundant
             raise ValueError(
                 f"Missing or invalid 'data' field (expected non-empty string): {message_data}"
             )
@@ -724,13 +726,13 @@ try:
             assert isinstance(REDIS_STREAM, str)
             assert isinstance(REDIS_CONSUMER_GROUP, str)
 
-            # Simplified xreadgroup call - redis-py handles encoding now
+            streams_arg: Dict[str, str] = {REDIS_STREAM: ">"}
+
             # With decode_responses=True, redis-py expects str types here
-            streams_arg = {REDIS_STREAM: ">"}
             messages = r.xreadgroup(
                 REDIS_CONSUMER_GROUP,
                 consumer_name,
-                streams_arg,
+                streams_arg,  # type: ignore[arg-type]
                 count=1,
                 block=5000,  # Use milliseconds for block
             )

{nebu-0.1.51 → nebu-0.1.53}/src/nebu/processors/decorate.py

@@ -1,11 +1,8 @@
 import ast  # For parsing notebook code
 import inspect
-import json  # Add json import
-import os  # Add os import
-import re  # Import re for fallback check
-import tempfile  # Add tempfile import
+import os
+import re  # Added import
 import textwrap
-import uuid  # Add uuid import
 from typing import (
     Any,
     Callable,
@@ -17,15 +14,15 @@ from typing import (
     get_origin,
     get_type_hints,
 )
-from urllib.parse import urlparse  # Add urlparse import
+from urllib.parse import urlparse
 
-import dill  # Add dill import
-import requests  # Add requests import
-from botocore.exceptions import ClientError  # Import ClientError
+import dill
+import requests
+from botocore.exceptions import ClientError
 from pydantic import BaseModel
 
-from nebu.auth import get_user_profile  # Import get_user_profile
-from nebu.config import GlobalConfig  # Add this import
+from nebu.auth import get_user_profile
+from nebu.config import GlobalConfig
 from nebu.containers.models import (
     V1AuthzConfig,
     V1ContainerHealthCheck,
@@ -38,7 +35,7 @@ from nebu.containers.models import (
     V1VolumeDriver,
     V1VolumePath,
 )
-from nebu.data import Bucket  # Import Bucket
+from nebu.data import Bucket
 from nebu.meta import V1ResourceMetaRequest
 from nebu.processors.models import (
     Message,
@@ -79,10 +76,11 @@ def is_jupyter_notebook():
 
         if importlib.util.find_spec("IPython") is None:
             return False
-        import IPython  # Now safe to import
+        # Fix: Import get_ipython directly
+        from IPython.core.getipython import get_ipython  # Now safe to import
 
-        ip = IPython.get_ipython()
-        if ip is None:
+        ip = get_ipython()  # Use the imported function
+        if ip is None:  # type: ignore
             # print("[DEBUG Helper] is_jupyter_notebook: No IPython instance found.")
             return False
         class_name = str(ip.__class__)
@@ -93,7 +91,9 @@ def is_jupyter_notebook():
         # print("[DEBUG Helper] 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
+        print(
+            f"[DEBUG Helper] is_jupyter_notebook: Exception occurred: {e}"
+        )  # Reduce verbosity
         return False
 
 
@@ -104,9 +104,10 @@ def get_notebook_executed_code():
     """
     print("[DEBUG Helper] Attempting to get notebook execution history...")
     try:
-        import IPython
+        # Fix: Import get_ipython directly
+        from IPython.core.getipython import get_ipython
 
-        ip = IPython.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."
@@ -164,9 +165,10 @@ def extract_definition_source_from_string(
             found_in_cell = False
             for node in ast.walk(tree):
                 if (
-                    isinstance(node, def_type)
-                    and hasattr(node, "name")
-                    and node.name == def_name
+                    isinstance(
+                        node, def_type
+                    )  # 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}."
@@ -188,10 +190,14 @@ def extract_definition_source_from_string(
                         start_lineno = getattr(node, "lineno", 1) - 1
                         end_lineno = getattr(node, "end_lineno", start_lineno + 1)
 
-                        if hasattr(node, "decorator_list") and node.decorator_list:
+                        if hasattr(node, "decorator_list") and node.decorator_list:  # type: ignore
+                            # Ensure it's a node type that *can* have decorators
+                            # FunctionDef and ClassDef have decorator_list
                             first_decorator_start_line = (
                                 getattr(
-                                    node.decorator_list[0], "lineno", start_lineno + 1
+                                    node.decorator_list[0],  # type: ignore
+                                    "lineno",
+                                    start_lineno + 1,
                                 )
                                 - 1
                             )  # type: ignore
@@ -598,28 +604,45 @@ 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):
+                    if isinstance(obj_source, str):  # type: ignore[arg-type]
                         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}")
                     elif isinstance(obj_source, tuple):
                         # Handle tuple source (origin, args) - assumes get_model_source/get_type_source logic
-                        origin_src, arg_srcs = obj_source
-                        if origin_src and isinstance(origin_src, str):
-                            all_env.append(
-                                V1EnvVar(key=f"{env_key_base}_SOURCE", value=origin_src)
-                            )
-                        for j, arg_src in enumerate(arg_srcs):
-                            if isinstance(arg_src, str):
+                        # 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
+                            if origin_src and isinstance(origin_src, str):
                                 all_env.append(
                                     V1EnvVar(
-                                        key=f"{env_key_base}_ARG_{j}_SOURCE",
-                                        value=arg_src,
+                                        key=f"{env_key_base}_SOURCE", value=origin_src
                                     )
                                 )
-                            # Handle nested tuples if necessary, or keep it simple
-                        # print(f"[DEBUG Decorator] Added tuple source to env for included obj: {obj_name_str}")
+                            # Handle arg_srcs (this part seems okay)
+                            if isinstance(arg_srcs, list):
+                                for j, arg_src in enumerate(arg_srcs):
+                                    if isinstance(arg_src, str):
+                                        all_env.append(
+                                            V1EnvVar(
+                                                key=f"{env_key_base}_ARG_{j}_SOURCE",
+                                                value=arg_src,
+                                            )
+                                        )
+                            else:
+                                print(
+                                    f"[DEBUG Decorator] Warning: 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}"
+                            )
                     else:
                         print(
                             f"Warning: Unknown source type for included object {obj_name_str}: {type(obj_source)}"
@@ -690,6 +713,7 @@ def processor(
         print(f"[DEBUG 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
 
         # Use Message class directly for comparison
         message_cls = Message  # Get the class object
@@ -709,18 +733,63 @@ def processor(
                 )
             else:
                 print(
-                    "[DEBUG Decorator] Message detected, but no generic arguments found via get_args."
+                    "[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}"
+                    )
+                else:
+                    print(
+                        "[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."
+            )
+            match = re.search(r"Message\[([\w\.]+)\]", param_type_str_repr)
+            if match:
+                print(
+                    "[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}"
+                )
+            else:
+                print(
+                    "[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:
-            print("[DEBUG Decorator] Input type identified as direct Message type.")
+            # 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."
+            )
             is_stream_message = True
-        # Check 3: Regex fallback might be less reliable now, but keep as last resort?
-        elif (
-            origin is None and param_type is not None
-        ):  # Only if origin failed and type exists
-            # ... (existing regex fallback logic using param_type_str_repr) ...
-            pass  # Keep existing regex logic here if desired
+            # --- 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}"
+                )
+            else:
+                print(
+                    "[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(
@@ -826,19 +895,44 @@ def processor(
         # Add: Included object sources (if any)
         # Add: INIT_FUNC_NAME (if provided)
 
-        # Basic info needed by consumer to find and run the function
-        all_env.append(V1EnvVar(key="FUNCTION_NAME", value=processor_name))
+        # Calculate module_path based on relative file path
+        calculated_module_path = None
         if rel_func_path:
             # Convert OS-specific path to module path (e.g., subdir/file.py -> subdir.file)
-            module_path = rel_func_path.replace(os.sep, ".")
-            if module_path.endswith(".py"):
-                module_path = module_path[:-3]
-            # Handle __init__.py -> treat as package name
-            if module_path.endswith(".__init__"):
-                module_path = module_path[: -len(".__init__")]
-            elif module_path == "__init__":  # Top-level __init__.py
-                module_path = ""  # Or handle differently? Let's assume it means import '.'? Maybe error?
+            base, ext = os.path.splitext(rel_func_path)
+            if ext == ".py":
+                module_path_parts = base.split(os.sep)
+                if module_path_parts[-1] == "__init__":
+                    module_path_parts.pop()  # Remove __init__
+                # Filter out potential empty strings if path started with / or had //
+                module_path_parts = [part for part in module_path_parts if part]
+                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}"
+                )
+                # 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__."
+            )
+            # Set calculated_module_path to None explicitly to trigger fallback later
+            calculated_module_path = None
+
+        # 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}")
+        else:
+            module_path = func.__module__  # Fallback
+            print(f"[DEBUG 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))
+        if rel_func_path:
             # For now, just pass the relative file path, consumer will handle conversion
             all_env.append(
                 V1EnvVar(key="NEBU_ENTRYPOINT_MODULE_PATH", value=rel_func_path)
@@ -846,9 +940,7 @@ def processor(
             print(
                 f"[DEBUG Decorator] Set NEBU_ENTRYPOINT_MODULE_PATH to: {rel_func_path}"
             )
-        else:
-            # Should have errored earlier if rel_func_path is None
-            raise RuntimeError("Internal error: Relative function path not determined.")
+        # No else needed, handled by fallback calculation above
 
         if init_func:
             init_func_name = init_func.__name__  # Get name here
@@ -862,26 +954,64 @@ def processor(
             print(f"[DEBUG 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
+        param_type_str_repr = str(param_type)
+        if module_path != "__main__" and "__main__." in param_type_str_repr:
+            # Be careful with replacement - replace only module prefix
+            # Example: "<class '__main__.MyModel'>" -> "<class 'mymodule.MyModel'>"
+            # Example: "typing.Optional[__main__.MyModel]" -> "typing.Optional[mymodule.MyModel]"
+            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}"
+            )
+
         all_env.append(V1EnvVar(key="PARAM_TYPE_STR", value=param_type_str_repr))
-        all_env.append(
-            V1EnvVar(key="RETURN_TYPE_STR", value=return_type_str_repr)
-        )  # Use repr
+
+        return_type_str_repr = str(return_type)
+        if module_path != "__main__" and "__main__." in return_type_str_repr:
+            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}"
+            )
+
+        all_env.append(V1EnvVar(key="RETURN_TYPE_STR", value=return_type_str_repr))
         all_env.append(V1EnvVar(key="IS_STREAM_MESSAGE", value=str(is_stream_message)))
-        if content_type and hasattr(content_type, "__name__"):
-            # Check if content_type is a class before accessing __name__
-            if isinstance(content_type, type):
-                all_env.append(
-                    V1EnvVar(key="CONTENT_TYPE_NAME", value=content_type.__name__)
-                )
-            else:
-                # Handle unresolved types / typevars if needed
+
+        # Determine and set CONTENT_TYPE_NAME using object or regex fallback
+        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}"
+            )
+        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}"
+            )
+        else:
+            # Only warn if it was supposed to be a Message type
+            if is_stream_message:
                 print(
-                    f"Warning: Content type '{content_type}' is not a class, cannot get name."
+                    f"Warning: Could not determine CONTENT_TYPE_NAME for Message parameter {param_name} ({param_type_str_repr}). Consumer might use raw content."
                 )
-        # MODULE_NAME might be less reliable now, depends on where func is defined relative to project root
+
+        if content_type_name_to_set:
+            all_env.append(
+                V1EnvVar(key="CONTENT_TYPE_NAME", value=content_type_name_to_set)
+            )
+
+        # Use the calculated module_path for MODULE_NAME
         all_env.append(
-            V1EnvVar(key="MODULE_NAME", value=func.__module__)
-        )  # Keep for potential debugging/info
+            V1EnvVar(
+                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}")
 
         # Add PYTHONPATH
         pythonpath_value = CONTAINER_CODE_DIR
@@ -1016,7 +1146,7 @@ def processor(
         # 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
+            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."

{nebu-0.1.51 → nebu-0.1.53/src/nebu.egg-info}/PKG-INFO

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