nebu 0.1.39__py3-none-any.whl → 0.1.41__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,5 @@ 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)

nebu/cache.py

@@ -1,8 +1,10 @@
 import os
+import socket  # Add socket import
 import time
 from typing import Any, Optional, cast
 
 import redis
+import socks  # Add socks import
 from pydantic import BaseModel, Field
 
 
@@ -36,6 +38,19 @@ class Cache:
         self.redis_client = None
         connection_info = ""
 
+        # Configure SOCKS proxy before connecting to Redis
+        try:
+            # Use the proxy settings provided by tailscaled
+            socks.set_default_proxy(socks.SOCKS5, "localhost", 1055)
+            socket.socket = socks.socksocket
+            print("Configured SOCKS5 proxy for socket connections via localhost:1055")
+        except Exception as proxy_err:
+            print(f"Failed to configure SOCKS proxy: {proxy_err}")
+            # Depending on requirements, you might want to raise an error here
+            # or proceed without the proxy if it's optional.
+            # For now, we'll print the error and continue, but the Redis connection
+            # will likely fail if the proxy is required.
+
         try:
             if redis_url:
                 # Use REDIS_URL if available

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,6 +846,33 @@ 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(

nebu/processors/processor.py

@@ -1,6 +1,7 @@
 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
@@ -141,7 +142,13 @@ 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]:
+        """
+        Allows the Processor instance to be called like a function, sending data.
+        """
+        return self.send(data=data, wait=wait)
+
+    def send(self, data: BaseModel, wait: bool = False) -> Dict[str, Any]:
         """
         Send data to the processor.
         """

{nebu-0.1.39.dist-info → nebu-0.1.41.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nebu
-Version: 0.1.39
+Version: 0.1.41
 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.39.dist-info → nebu-0.1.41.dist-info}/RECORD

@@ -1,7 +1,7 @@
 nebu/__init__.py,sha256=5sepbzdAdoA_8TIxws60S4ugFY1apQd_savzn20a4cY,465
-nebu/adapter.py,sha256=X9Lc0-pm4U6v7UDgOd_RuxJqENqAO8Si4jrwGYTsMGI,418
+nebu/adapter.py,sha256=yELhnYDsb56vI4xb_fpgZehsr9GQwiNY1tcasO2IQQo,546
 nebu/auth.py,sha256=N_v6SPFD9HU_UoRDTaouH03g2Hmo9C-xxqInE1FweXE,1471
-nebu/cache.py,sha256=nKssfJ4mqkxkzoU776cr7RjOSbKoueqNvmHvQ0Ufj70,3929
+nebu/cache.py,sha256=jmluqvWnE9N8uNq6nppXSxEJK7DKWaB79GicaGg9KmY,4718
 nebu/config.py,sha256=aZzQltkobtOLHFCGcIkpKoE3ITn3Z11Dp0E72w84TA0,5769
 nebu/data.py,sha256=kIH9-JJ1-iO7P2t28bku6Gn0Y5tgQszGeTW_rpmO03A,38725
 nebu/meta.py,sha256=CzFHMND9seuewzq9zNNx9WTr6JvrCBExe7BLqDSr7lM,745
@@ -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=ltYo2DMBsMJek2AZe4o0w9eFVo3qFCfGg7oRYlskRvU,40144
 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=lN1T665WV-d45gerGBgb8HxVVc2k52U3hxIBaAfe-Nk,9991
 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.39.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-nebu-0.1.39.dist-info/METADATA,sha256=aAJh9bd6ya9FoUBkqpxnAsk6T6Vwtwtz6g5hhMl28PY,1786
-nebu-0.1.39.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-nebu-0.1.39.dist-info/top_level.txt,sha256=uLIbEKJeGSHWOAJN5S0i5XBGwybALlF9bYoB1UhdEgQ,5
-nebu-0.1.39.dist-info/RECORD,,
+nebu-0.1.41.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+nebu-0.1.41.dist-info/METADATA,sha256=OohCbzIvc4-hH0OzVDsWQJpOfAsi7kH9WqHOIqGo_f4,1738
+nebu-0.1.41.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+nebu-0.1.41.dist-info/top_level.txt,sha256=uLIbEKJeGSHWOAJN5S0i5XBGwybALlF9bYoB1UhdEgQ,5
+nebu-0.1.41.dist-info/RECORD,,