nebu 0.1.7__py3-none-any.whl → 0.1.9__py3-none-any.whl

nebu/auth.py

@@ -0,0 +1,35 @@
+from typing import Dict, Optional
+
+import requests
+from pydantic import BaseModel
+
+from nebu.config import GlobalConfig
+
+
+class V1UserProfile(BaseModel):
+    email: str
+    display_name: Optional[str] = None
+    handle: Optional[str] = None
+    picture: Optional[str] = None
+    organization: Optional[str] = None
+    role: Optional[str] = None
+    external_id: Optional[str] = None
+    actor: Optional[str] = None
+    # structure is {"org_id": {"org_name": <name>, "org_role": <role>}}
+    organizations: Optional[Dict[str, Dict[str, str]]] = None
+    created: Optional[int] = None
+    updated: Optional[int] = None
+    token: Optional[str] = None
+
+
+def get_user_profile(api_key: str) -> V1UserProfile:
+    config = GlobalConfig.read()
+    current_server_config = config.get_current_server_config()
+    if current_server_config is None:
+        raise ValueError("No current server config found")
+    url = f"{current_server_config.server}/v1/users/me"
+
+    response = requests.get(url, headers={"Authorization": f"Bearer {api_key}"})
+    response.raise_for_status()
+
+    return V1UserProfile.model_validate(response.json())

nebu/containers/models.py

@@ -75,6 +75,7 @@ class V1ContainerStatus(BaseModel):
     accelerator: Optional[str] = None
     tailnet_url: Optional[str] = None
     cost_per_hr: Optional[float] = None
+    ready: Optional[bool] = None
 
 
 class V1AuthzSecretRef(BaseModel):

nebu/processors/consumer.py

@@ -0,0 +1,414 @@
+#!/usr/bin/env python3
+import json
+import os
+import sys
+import time
+import traceback
+from datetime import datetime
+from typing import Dict, TypeVar
+
+import redis
+
+# Define TypeVar for generic models
+T = TypeVar("T")
+
+# Get function and model source code and create them dynamically
+try:
+    function_source = os.environ.get("FUNCTION_SOURCE")
+    function_name = os.environ.get("FUNCTION_NAME")
+    stream_message_source = os.environ.get("STREAM_MESSAGE_SOURCE")
+    input_model_source = os.environ.get("INPUT_MODEL_SOURCE")
+    output_model_source = os.environ.get("OUTPUT_MODEL_SOURCE")
+    content_type_source = os.environ.get("CONTENT_TYPE_SOURCE")
+    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")
+    content_type_name = os.environ.get("CONTENT_TYPE_NAME")
+
+    # Check for generic type arguments
+    input_model_args = []
+    output_model_args = []
+    content_type_args = []
+
+    # Get input model arg sources
+    i = 0
+    while True:
+        arg_source = os.environ.get(f"INPUT_MODEL_ARG_{i}_SOURCE")
+        if arg_source:
+            input_model_args.append(arg_source)
+            i += 1
+        else:
+            break
+
+    # Get output model arg sources
+    i = 0
+    while True:
+        arg_source = os.environ.get(f"OUTPUT_MODEL_ARG_{i}_SOURCE")
+        if arg_source:
+            output_model_args.append(arg_source)
+            i += 1
+        else:
+            break
+
+    # Get content type arg sources
+    i = 0
+    while True:
+        arg_source = os.environ.get(f"CONTENT_TYPE_ARG_{i}_SOURCE")
+        if arg_source:
+            content_type_args.append(arg_source)
+            i += 1
+        else:
+            break
+
+    # Get included object sources
+    included_object_sources = []
+    i = 0
+    while True:
+        obj_source = os.environ.get(f"INCLUDED_OBJECT_{i}_SOURCE")
+        if obj_source:
+            args = []
+            j = 0
+            while True:
+                arg_source = os.environ.get(f"INCLUDED_OBJECT_{i}_ARG_{j}_SOURCE")
+                if arg_source:
+                    args.append(arg_source)
+                    j += 1
+                else:
+                    break
+            included_object_sources.append((obj_source, args))
+            i += 1
+        else:
+            break
+
+    if not function_source or not function_name:
+        print("FUNCTION_SOURCE or FUNCTION_NAME environment variables not set")
+        sys.exit(1)
+
+    # Create a local namespace for executing the function
+    local_namespace = {}
+
+    # Include pydantic BaseModel and typing tools for type annotations
+    exec("from pydantic import BaseModel, Field", local_namespace)
+    exec(
+        "from typing import Optional, List, Dict, Any, Generic, TypeVar",
+        local_namespace,
+    )
+    exec("T = TypeVar('T')", local_namespace)
+
+    # 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."
+        )
+
+    # Define the models
+    # First define stream message class if needed
+    if stream_message_source:
+        try:
+            exec(stream_message_source, local_namespace)
+            print("Successfully defined V1StreamMessage class")
+        except Exception as e:
+            print(f"Error defining V1StreamMessage: {e}")
+            traceback.print_exc()
+
+    # 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 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}")
+
+            # 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 output model
+    if output_model_source:
+        try:
+            exec(output_model_source, local_namespace)
+            print(f"Successfully defined output model {return_type_name}")
+
+            # 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 included object sources
+    for i, (obj_source, args_sources) in enumerate(included_object_sources):
+        try:
+            exec(obj_source, local_namespace)
+            print(f"Successfully executed included object {i} base source")
+            for j, arg_source in enumerate(args_sources):
+                try:
+                    exec(arg_source, local_namespace)
+                    print(f"Successfully executed included object {i} arg {j} source")
+                except Exception as e:
+                    print(f"Error executing included object {i} arg {j} source: {e}")
+                    traceback.print_exc()
+        except Exception as e:
+            print(f"Error executing included object {i} base source: {e}")
+            traceback.print_exc()
+
+    # Finally, execute the function code
+    try:
+        exec(function_source, local_namespace)
+        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)
+
+except Exception as e:
+    print(f"Error setting up function: {e}")
+    traceback.print_exc()
+    sys.exit(1)
+
+# Get Redis connection parameters from environment
+REDIS_URL = os.environ.get("REDIS_URL", "")
+REDIS_CONSUMER_GROUP = os.environ.get("REDIS_CONSUMER_GROUP")
+REDIS_STREAM = os.environ.get("REDIS_STREAM")
+
+if not all([REDIS_URL, REDIS_CONSUMER_GROUP, REDIS_STREAM]):
+    print("Missing required Redis environment variables")
+    sys.exit(1)
+
+# Connect to Redis
+try:
+    r = redis.from_url(REDIS_URL)
+    redis_info = REDIS_URL.split("@")[-1] if "@" in REDIS_URL else REDIS_URL
+    print(f"Connected to Redis at {redis_info}")
+except Exception as e:
+    print(f"Failed to connect to Redis: {e}")
+    traceback.print_exc()
+    sys.exit(1)
+
+# Create consumer group if it doesn't exist
+try:
+    r.xgroup_create(REDIS_STREAM, REDIS_CONSUMER_GROUP, id="0", mkstream=True)
+    print(f"Created consumer group {REDIS_CONSUMER_GROUP} for stream {REDIS_STREAM}")
+except redis.exceptions.ResponseError as e:
+    if "BUSYGROUP" in str(e):
+        print(f"Consumer group {REDIS_CONSUMER_GROUP} already exists")
+    else:
+        print(f"Error creating consumer group: {e}")
+        traceback.print_exc()
+
+
+# Function to process messages
+def process_message(message_id: bytes, message_data: Dict[bytes, bytes]) -> None:
+    # Initialize variables that need to be accessible in the except block
+    return_stream = None
+    user_id = None
+
+    try:
+        # Get the message content from field 'data'
+        if b"data" not in message_data:
+            print(f"Message {message_id} has no 'data' field")
+            return
+
+        # Parse the message data
+        raw_payload = json.loads(message_data[b"data"].decode("utf-8"))
+
+        # Extract fields from the Rust structure
+        # These fields are extracted for completeness and potential future use
+        _ = raw_payload.get("kind", "")  # kind
+        msg_id = raw_payload.get("id", "")  # msg_id
+        content_raw = raw_payload.get("content", {})
+        created_at = raw_payload.get("created_at", 0)  # created_at
+        return_stream = raw_payload.get("return_stream")
+        user_id = raw_payload.get("user_id")
+        orgs = raw_payload.get("organizations")  # organizations
+        handle = raw_payload.get("handle")  # handle
+        adapter = raw_payload.get("adapter")  # adapter
+
+        # Parse the content field if it's a string
+        if isinstance(content_raw, str):
+            try:
+                content = json.loads(content_raw)
+            except json.JSONDecodeError:
+                content = content_raw
+        else:
+            content = content_raw
+
+        # For StreamMessage, construct the proper input object
+        if is_stream_message and "V1StreamMessage" in local_namespace:
+            # If we have a content type, try to construct it
+            if content_type_name and content_type_name in local_namespace:
+                # Try to create the content type model first
+                try:
+                    content_model = local_namespace[content_type_name](**content)
+                    input_obj = local_namespace["V1StreamMessage"](
+                        kind=_,
+                        id=msg_id,
+                        content=content_model,
+                        created_at=created_at,
+                        return_stream=return_stream,
+                        user_id=user_id,
+                        orgs=orgs,
+                        handle=handle,
+                        adapter=adapter,
+                    )
+                except Exception as e:
+                    print(f"Error creating content type model: {e}")
+                    # Fallback to using raw content
+                    input_obj = local_namespace["V1StreamMessage"](
+                        kind=_,
+                        id=msg_id,
+                        content=content,
+                        created_at=created_at,
+                        return_stream=return_stream,
+                        user_id=user_id,
+                        orgs=orgs,
+                        handle=handle,
+                        adapter=adapter,
+                    )
+            else:
+                # Just use the raw content
+                input_obj = local_namespace["V1StreamMessage"](
+                    kind=_,
+                    id=msg_id,
+                    content=content,
+                    created_at=created_at,
+                    return_stream=return_stream,
+                    user_id=user_id,
+                    orgs=orgs,
+                    handle=handle,
+                    adapter=adapter,
+                )
+        else:
+            # Otherwise use the param type directly
+            try:
+                if param_type_name in local_namespace:
+                    input_obj = local_namespace[param_type_name](**content)
+                else:
+                    # If we can't find the exact type, just pass the content directly
+                    input_obj = content
+            except Exception as e:
+                print(f"Error creating input model: {e}, using raw content")
+                input_obj = content
+
+        # Execute the function
+        result = target_function(input_obj)
+
+        # If the result is a Pydantic model, convert to dict
+        if hasattr(result, "model_dump"):
+            result = result.model_dump()
+
+        # Prepare the response
+        response = {
+            "kind": "StreamResponseMessage",
+            "id": message_id.decode("utf-8"),
+            "content": result,
+            "status": "success",
+            "created_at": datetime.now().isoformat(),
+            "user_id": user_id,
+        }
+
+        # Send the result to the return stream
+        if return_stream:
+            r.xadd(return_stream, {"data": json.dumps(response)})
+            print(
+                f"Processed message {message_id.decode('utf-8')}, result sent to {return_stream}"
+            )
+
+        # Acknowledge the message
+        r.xack(REDIS_STREAM, REDIS_CONSUMER_GROUP, message_id)
+
+    except Exception as e:
+        print(f"Error processing message {message_id.decode('utf-8')}: {e}")
+        traceback.print_exc()
+
+        # Prepare the error response
+        error_response = {
+            "kind": "StreamResponseMessage",
+            "id": message_id.decode("utf-8"),
+            "content": {
+                "error": str(e),
+                "traceback": traceback.format_exc(),
+            },
+            "status": "error",
+            "created_at": datetime.now().isoformat(),
+            "user_id": user_id,
+        }
+
+        # Send the error to the return stream
+        if return_stream:
+            r.xadd(return_stream, {"data": json.dumps(error_response)})
+        else:
+            r.xadd(f"{REDIS_STREAM}.errors", {"data": json.dumps(error_response)})
+
+        # Still acknowledge the message so we don't reprocess it
+        r.xack(REDIS_STREAM, REDIS_CONSUMER_GROUP, message_id)
+
+
+# Main loop
+print(f"Starting consumer for stream {REDIS_STREAM} in group {REDIS_CONSUMER_GROUP}")
+consumer_name = f"consumer-{os.getpid()}"
+
+while True:
+    try:
+        # Read from stream with blocking
+        streams = {REDIS_STREAM: ">"}  # '>' means read only new messages
+        messages = r.xreadgroup(
+            REDIS_CONSUMER_GROUP, consumer_name, streams, count=1, block=5000
+        )
+
+        if not messages:
+            # No messages received, continue waiting
+            continue
+
+        stream_name, stream_messages = messages[0]
+
+        for message_id, message_data in stream_messages:
+            process_message(message_id, message_data)
+
+    except redis.exceptions.ConnectionError as e:
+        print(f"Redis connection error: {e}")
+        time.sleep(5)  # Wait before retrying
+
+    except Exception as e:
+        print(f"Unexpected error: {e}")
+        traceback.print_exc()
+        time.sleep(1)  # Brief pause before continuing

nebu/processors/decorate.py

@@ -0,0 +1,360 @@
+import inspect
+import textwrap
+from typing import Any, Callable, Dict, List, Optional, TypeVar, get_type_hints
+
+from pydantic import BaseModel
+
+from nebu.containers.models import (
+    V1AuthzConfig,
+    V1ContainerRequest,
+    V1ContainerResources,
+    V1EnvVar,
+    V1Meter,
+    V1VolumePath,
+)
+from nebu.meta import V1ResourceMetaRequest
+from nebu.processors.models import (
+    V1Scale,
+    V1StreamMessage,
+)
+from nebu.processors.processor import Processor
+
+from .default import DEFAULT_MAX_REPLICAS, DEFAULT_MIN_REPLICAS, DEFAULT_SCALE
+
+T = TypeVar("T", bound=BaseModel)
+R = TypeVar("R", bound=BaseModel)
+
+
+def get_model_source(model_class: Any) -> Optional[str]:
+    """Get the source code of a model class."""
+    try:
+        source = inspect.getsource(model_class)
+        return textwrap.dedent(source)
+    except (IOError, TypeError):
+        return None
+
+
+def get_type_source(type_obj: Any) -> Optional[Any]:
+    """Get the source code for a type, including generic parameters."""
+    # If it's a class, get its source
+    if isinstance(type_obj, type):
+        return get_model_source(type_obj)
+
+    # If it's a GenericAlias (like V1StreamMessage[SomeType])
+    if hasattr(type_obj, "__origin__") and hasattr(type_obj, "__args__"):
+        origin_source = get_model_source(type_obj.__origin__)
+        args_sources = []
+
+        # Get sources for all type arguments
+        for arg in type_obj.__args__:
+            arg_source = get_type_source(arg)
+            if arg_source:
+                args_sources.append(arg_source)
+
+        return origin_source, args_sources
+
+    return None
+
+
+def processor(
+    image: str,
+    setup_script: Optional[str] = None,
+    scale: V1Scale = DEFAULT_SCALE,
+    min_replicas: int = DEFAULT_MIN_REPLICAS,
+    max_replicas: int = DEFAULT_MAX_REPLICAS,
+    platform: Optional[str] = None,
+    accelerators: Optional[List[str]] = None,
+    namespace: Optional[str] = None,
+    labels: Optional[Dict[str, str]] = None,
+    env: Optional[List[V1EnvVar]] = None,
+    volumes: Optional[List[V1VolumePath]] = None,
+    resources: Optional[V1ContainerResources] = None,
+    meters: Optional[List[V1Meter]] = None,
+    authz: Optional[V1AuthzConfig] = None,
+    python_cmd: str = "python",
+    no_delete: bool = False,
+    include: Optional[List[Any]] = None,
+):
+    """
+    Decorator that converts a function into a Processor.
+
+    Args:
+        image: The container image to use for the processor
+        setup_script: Optional setup script to run before starting the processor
+        scale: Optional scaling configuration
+        min_replicas: Minimum number of replicas to maintain
+        max_replicas: Maximum number of replicas to scale to
+        platform: Optional compute platform to run on
+        accelerators: Optional list of accelerator types
+        namespace: Optional namespace for the processor
+        labels: Optional labels to apply to the processor
+        env: Optional environment variables
+        volumes: Optional volume mounts
+        resources: Optional resource requirements
+        meters: Optional metering configuration
+        authz: Optional authorization configuration
+        python_cmd: Optional python command to use
+        no_delete: Whether to prevent deleting the processor on updates
+        include: Optional list of Python objects whose source code should be included
+    """
+
+    def decorator(func: Callable[[T], R]) -> Processor:
+        # Validate that the function takes a single parameter that is a BaseModel
+        sig = inspect.signature(func)
+        params = list(sig.parameters.values())
+
+        if len(params) != 1:
+            raise TypeError(f"Function {func.__name__} must take exactly one parameter")
+
+        # Check parameter type
+        type_hints = get_type_hints(func)
+        param_name = params[0].name
+        if param_name not in type_hints:
+            raise TypeError(
+                f"Parameter {param_name} in function {func.__name__} must have a type annotation"
+            )
+
+        param_type = type_hints[param_name]
+
+        # Check if input type is V1StreamMessage or a subclass
+        is_stream_message = False
+        content_type = None
+
+        # Handle generic V1StreamMessage
+        if (
+            hasattr(param_type, "__origin__")
+            and param_type.__origin__ == V1StreamMessage
+        ):
+            is_stream_message = True
+            # Extract the content type from V1StreamMessage[ContentType]
+            if hasattr(param_type, "__args__") and param_type.__args__:
+                content_type = param_type.__args__[0]
+        # Handle direct V1StreamMessage
+        elif param_type is V1StreamMessage:
+            is_stream_message = True
+
+        # Ensure the parameter is a BaseModel
+        actual_type = (
+            param_type.__origin__ if hasattr(param_type, "__origin__") else param_type  # type: ignore
+        )
+        if not issubclass(actual_type, BaseModel):
+            raise TypeError(
+                f"Parameter {param_name} in function {func.__name__} must be a BaseModel"
+            )
+
+        # Check return type
+        if "return" not in type_hints:
+            raise TypeError(
+                f"Function {func.__name__} must have a return type annotation"
+            )
+
+        return_type = type_hints["return"]
+        actual_return_type = (
+            return_type.__origin__
+            if hasattr(return_type, "__origin__")
+            else return_type
+        )
+        if not issubclass(actual_return_type, BaseModel):
+            raise TypeError(
+                f"Return value of function {func.__name__} must be a BaseModel"
+            )
+
+        # Get function name to use as processor name
+        processor_name = func.__name__
+
+        # Prepare environment variables
+        all_env = env or []
+
+        # Get the source code of the function
+        try:
+            function_source = inspect.getsource(func)
+            # Clean up the indentation
+            function_source = textwrap.dedent(function_source)
+        except (IOError, TypeError):
+            raise ValueError(
+                f"Could not retrieve source code for function {func.__name__}"
+            )
+
+        # Get source code for the models
+        input_model_source = None
+        output_model_source = None
+        content_type_source = None
+
+        # Get the V1StreamMessage class source
+        stream_message_source = get_model_source(V1StreamMessage)
+
+        # Get input model source
+        if is_stream_message:
+            input_model_source = stream_message_source
+            if content_type:
+                content_type_source = get_type_source(content_type)
+        else:
+            input_model_source = get_type_source(param_type)
+
+        # Get output model source
+        output_model_source = get_type_source(return_type)
+
+        # Add function source code to environment variables
+        all_env.append(V1EnvVar(key="FUNCTION_SOURCE", value=function_source))
+        all_env.append(V1EnvVar(key="FUNCTION_NAME", value=func.__name__))
+
+        # Add model source codes
+        if input_model_source:
+            if isinstance(input_model_source, tuple):
+                all_env.append(
+                    V1EnvVar(key="INPUT_MODEL_SOURCE", value=input_model_source[0])
+                )
+                # Add generic args sources
+                for i, arg_source in enumerate(input_model_source[1]):
+                    all_env.append(
+                        V1EnvVar(key=f"INPUT_MODEL_ARG_{i}_SOURCE", value=arg_source)
+                    )
+            else:
+                all_env.append(
+                    V1EnvVar(key="INPUT_MODEL_SOURCE", value=input_model_source)
+                )
+
+        if output_model_source:
+            if isinstance(output_model_source, tuple):
+                all_env.append(
+                    V1EnvVar(key="OUTPUT_MODEL_SOURCE", value=output_model_source[0])
+                )
+                # Add generic args sources
+                for i, arg_source in enumerate(output_model_source[1]):
+                    all_env.append(
+                        V1EnvVar(key=f"OUTPUT_MODEL_ARG_{i}_SOURCE", value=arg_source)
+                    )
+            else:
+                all_env.append(
+                    V1EnvVar(key="OUTPUT_MODEL_SOURCE", value=output_model_source)
+                )
+
+        if stream_message_source:
+            all_env.append(
+                V1EnvVar(key="STREAM_MESSAGE_SOURCE", value=stream_message_source)
+            )
+
+        if content_type_source:
+            if isinstance(content_type_source, tuple):
+                all_env.append(
+                    V1EnvVar(key="CONTENT_TYPE_SOURCE", value=content_type_source[0])
+                )
+                # Add generic args sources for content type
+                for i, arg_source in enumerate(content_type_source[1]):
+                    all_env.append(
+                        V1EnvVar(key=f"CONTENT_TYPE_ARG_{i}_SOURCE", value=arg_source)
+                    )
+            else:
+                all_env.append(
+                    V1EnvVar(key="CONTENT_TYPE_SOURCE", value=content_type_source)
+                )
+
+        # Add included object sources
+        if include:
+            for i, obj in enumerate(include):
+                obj_source = get_type_source(
+                    obj
+                )  # Reuse existing function for source retrieval
+                if obj_source:
+                    if isinstance(obj_source, tuple):
+                        # Handle complex types (like generics) if needed, similar to models
+                        all_env.append(
+                            V1EnvVar(
+                                key=f"INCLUDED_OBJECT_{i}_SOURCE", value=obj_source[0]
+                            )
+                        )
+                        for j, arg_source in enumerate(obj_source[1]):
+                            all_env.append(
+                                V1EnvVar(
+                                    key=f"INCLUDED_OBJECT_{i}_ARG_{j}_SOURCE",
+                                    value=arg_source,
+                                )
+                            )
+                    else:
+                        all_env.append(
+                            V1EnvVar(
+                                key=f"INCLUDED_OBJECT_{i}_SOURCE", value=obj_source
+                            )
+                        )
+                else:
+                    # Optionally raise an error or log a warning if source can't be found
+                    print(
+                        f"Warning: Could not retrieve source for included object: {obj}"
+                    )
+
+        # Add parameter and return type info for runtime validation
+        all_env.append(
+            V1EnvVar(
+                key="PARAM_TYPE_NAME",
+                value=param_type.__name__
+                if hasattr(param_type, "__name__")
+                else str(param_type),
+            )
+        )
+        all_env.append(
+            V1EnvVar(
+                key="RETURN_TYPE_NAME",
+                value=return_type.__name__
+                if hasattr(return_type, "__name__")
+                else str(return_type),
+            )
+        )
+        all_env.append(V1EnvVar(key="IS_STREAM_MESSAGE", value=str(is_stream_message)))
+
+        if content_type:
+            all_env.append(
+                V1EnvVar(
+                    key="CONTENT_TYPE_NAME",
+                    value=content_type.__name__
+                    if hasattr(content_type, "__name__")
+                    else str(content_type),
+                )
+            )
+
+        # We still add the module for reference, but we won't rely on importing it
+        all_env.append(V1EnvVar(key="MODULE_NAME", value=func.__module__))
+
+        # Prepare metadata
+        metadata = V1ResourceMetaRequest(
+            name=processor_name, namespace=namespace, labels=labels
+        )
+
+        # Create the command to run the consumer directly
+        consumer_command = f"{python_cmd} -m nebu.processors.consumer"
+
+        final_command = f"{python_cmd} -m pip install redis nebu\n\n{setup_script}\n\n{consumer_command}"
+
+        # Create the V1ContainerRequest
+        container_request = V1ContainerRequest(
+            image=image,
+            command=final_command,
+            env=all_env,
+            volumes=volumes,
+            accelerators=accelerators,
+            resources=resources,
+            meters=meters,
+            restart="Always",
+            authz=authz,
+            platform=platform,
+            metadata=metadata,
+        )
+        print("container_request", container_request)
+
+        # Create the processor instance
+        processor_instance = Processor(
+            name=processor_name,
+            stream=processor_name,
+            namespace=namespace,
+            labels=labels,
+            container=container_request,
+            schema_=None,  # TODO
+            common_schema=None,
+            min_replicas=min_replicas,
+            max_replicas=max_replicas,
+            scale_config=scale,
+            no_delete=no_delete,
+        )
+
+        return processor_instance
+
+    return decorator

nebu/processors/default.py

@@ -0,0 +1,18 @@
+from nebu.processors.models import V1Scale, V1ScaleDown, V1ScaleUp, V1ScaleZero
+
+DEFAULT_SCALE = V1Scale(
+    up=V1ScaleUp(
+        above_pressure=30,
+        duration="1m",
+    ),
+    down=V1ScaleDown(
+        below_pressure=2,
+        duration="1m",
+    ),
+    zero=V1ScaleZero(
+        duration="5m",
+    ),
+)
+
+DEFAULT_MIN_REPLICAS = 1
+DEFAULT_MAX_REPLICAS = 10

nebu/processors/models.py

@@ -1,16 +1,13 @@
-from typing import Any, Optional
+from typing import Any, Generic, List, Optional, TypeVar
 
 from pydantic import BaseModel, Field
 
-from nebu.containers.models import V1Container
-from nebu.meta import V1ResourceMeta, V1ResourceMetaRequest
+# Assuming these are imported from other modules
+from nebu.containers.models import V1ContainerRequest
+from nebu.meta import V1ResourceMeta, V1ResourceMetaRequest, V1ResourceReference
 
-# If these are in another module, import them as:
-# from .containers import V1Container, V1ResourceMeta, V1ResourceMetaRequest
-# For demonstration, simply assume they're available in scope:
-# class V1Container(BaseModel): ...
-# class V1ResourceMeta(BaseModel): ...
-# class V1ResourceMetaRequest(BaseModel): ...
+# Type variable for content that must be a BaseModel
+T = TypeVar("T", bound=BaseModel)
 
 
 class V1ProcessorStatus(BaseModel):
@@ -39,29 +36,120 @@ class V1Scale(BaseModel):
     zero: Optional[V1ScaleZero] = None
 
 
-DEFAULT_PROCESSOR_KIND = "Processor"
+def default_processor_kind() -> str:
+    return "Processor"
 
 
 class V1Processor(BaseModel):
-    kind: str = Field(default=DEFAULT_PROCESSOR_KIND)
+    kind: str = Field(default_factory=default_processor_kind)
     metadata: V1ResourceMeta
-    container: Optional["V1Container"] = None
-    stream: Optional[str] = None
-    schema_: Optional[Any] = None  # Or Dict[str, Any], if you know the schema format
+    container: Optional[V1ContainerRequest] = None
+    stream: str
+    schema_: Optional[Any] = None
     common_schema: Optional[str] = None
     min_replicas: Optional[int] = None
     max_replicas: Optional[int] = None
     scale: Optional[V1Scale] = None
     status: Optional[V1ProcessorStatus] = None
 
+    def to_resource_reference(self) -> V1ResourceReference:
+        return V1ResourceReference(
+            kind=self.kind,
+            name=self.metadata.name,
+            namespace=self.metadata.namespace,
+        )
+
 
 class V1ProcessorRequest(BaseModel):
-    kind: str = Field(default=DEFAULT_PROCESSOR_KIND)
+    kind: str = Field(default_factory=default_processor_kind)
     metadata: V1ResourceMetaRequest
-    container: Optional["V1Container"] = None
-    stream: Optional[str] = None
+    container: Optional[V1ContainerRequest] = None
     schema_: Optional[Any] = None
     common_schema: Optional[str] = None
     min_replicas: Optional[int] = None
     max_replicas: Optional[int] = None
     scale: Optional[V1Scale] = None
+
+
+class V1Processors(BaseModel):
+    processors: List[V1Processor] = []
+
+
+class V1ProcessorScaleRequest(BaseModel):
+    replicas: Optional[int] = None
+    min_replicas: Optional[int] = None
+
+
+class V1UpdateProcessor(BaseModel):
+    kind: Optional[str] = None
+    metadata: Optional[V1ResourceMetaRequest] = None
+    container: Optional[V1ContainerRequest] = None
+    stream: Optional[str] = None
+    min_replicas: Optional[int] = None
+    max_replicas: Optional[int] = None
+    scale: Optional[V1Scale] = None
+    schema_: Optional[Any] = None
+    common_schema: Optional[str] = None
+    no_delete: Optional[bool] = None
+
+
+def kind_v1_stream_message() -> str:
+    return "StreamMessage"
+
+
+def kind_v1_stream_response_message() -> str:
+    return "StreamResponseMessage"
+
+
+def kind_v1_openai_stream_message() -> str:
+    return "OpenAIStreamMessage"
+
+
+def kind_v1_openai_stream_response() -> str:
+    return "OpenAIStreamResponse"
+
+
+class V1StreamData(BaseModel):
+    content: Any = None
+    wait: Optional[bool] = None
+
+
+class V1StreamMessage(Generic[T], BaseModel):
+    kind: str = Field(default_factory=kind_v1_stream_message)
+    id: str
+    content: Optional[T] = None
+    created_at: int
+    return_stream: Optional[str] = None
+    user_id: Optional[str] = None
+    orgs: Optional[Any] = None
+    handle: Optional[str] = None
+    adapter: Optional[str] = None
+
+
+class V1StreamResponseMessage(BaseModel):
+    kind: str = Field(default_factory=kind_v1_stream_response_message)
+    id: str
+    content: Any = None
+    status: Optional[str] = None
+    created_at: int
+    user_id: Optional[str] = None
+
+
+class V1OpenAIStreamMessage(BaseModel):
+    kind: str = Field(default_factory=kind_v1_openai_stream_message)
+    id: str
+    content: Any  # Using Any for ChatCompletionRequest
+    created_at: int
+    return_stream: Optional[str] = None
+    user_id: Optional[str] = None
+    orgs: Optional[Any] = None
+    handle: Optional[str] = None
+    adapter: Optional[str] = None
+
+
+class V1OpenAIStreamResponse(BaseModel):
+    kind: str = Field(default_factory=kind_v1_openai_stream_response)
+    id: str
+    content: Any  # Using Any for ChatCompletionResponse
+    created_at: int
+    user_id: Optional[str] = None

nebu/processors/processor.py

@@ -0,0 +1,277 @@
+from typing import Any, Dict, List, Optional
+
+import requests
+
+from nebu.auth import get_user_profile
+from nebu.config import GlobalConfig
+from nebu.meta import V1ResourceMetaRequest
+from nebu.processors.models import (
+    V1ContainerRequest,
+    V1Processor,
+    V1ProcessorRequest,
+    V1Processors,
+    V1ProcessorScaleRequest,
+    V1Scale,
+    V1UpdateProcessor,
+)
+
+
+class Processor:
+    """
+    A class for managing Processor instances.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        stream: str,
+        namespace: Optional[str] = None,
+        labels: Optional[Dict[str, str]] = None,
+        container: Optional[V1ContainerRequest] = None,
+        schema_: Optional[Any] = None,
+        common_schema: Optional[str] = None,
+        min_replicas: Optional[int] = None,
+        max_replicas: Optional[int] = None,
+        scale_config: Optional[V1Scale] = None,
+        config: Optional[GlobalConfig] = None,
+        no_delete: bool = False,
+    ):
+        self.config = config or GlobalConfig.read()
+        if not self.config:
+            raise ValueError("No config found")
+        current_server = self.config.get_current_server_config()
+        if not current_server:
+            raise ValueError("No server config found")
+        self.current_server = current_server
+        self.api_key = current_server.api_key
+        self.orign_host = current_server.server
+        self.name = name
+        self.namespace = namespace
+        self.labels = labels
+        self.stream = stream
+        self.container = container
+        self.schema_ = schema_
+        self.common_schema = common_schema
+        self.min_replicas = min_replicas
+        self.max_replicas = max_replicas
+        self.scale_config = scale_config
+        self.processors_url = f"{self.orign_host}/v1/processors"
+
+        # Fetch existing Processors
+        response = requests.get(
+            self.processors_url, headers={"Authorization": f"Bearer {self.api_key}"}
+        )
+        response.raise_for_status()
+
+        if not namespace:
+            if not self.api_key:
+                raise ValueError("No API key provided")
+
+            user_profile = get_user_profile(self.api_key)
+            namespace = user_profile.handle
+
+            if not namespace:
+                namespace = user_profile.email.replace("@", "-").replace(".", "-")
+
+        print(f"Using namespace: {namespace}")
+
+        existing_processors = V1Processors.model_validate(response.json())
+        print(f"Existing processors: {existing_processors}")
+        self.processor: Optional[V1Processor] = next(
+            (
+                processor_val
+                for processor_val in existing_processors.processors
+                if processor_val.metadata.name == name
+                and processor_val.metadata.namespace == namespace
+            ),
+            None,
+        )
+        print(f"Processor: {self.processor}")
+
+        # If not found, create
+        if not self.processor:
+            print("Creating processor")
+            # Create metadata and processor request
+            metadata = V1ResourceMetaRequest(
+                name=name, namespace=namespace, labels=labels
+            )
+
+            processor_request = V1ProcessorRequest(
+                metadata=metadata,
+                container=container,
+                schema_=schema_,
+                common_schema=common_schema,
+                min_replicas=min_replicas,
+                max_replicas=max_replicas,
+                scale=scale_config,
+            )
+
+            print("Request:")
+            print(processor_request.model_dump(exclude_none=True))
+            create_response = requests.post(
+                self.processors_url,
+                json=processor_request.model_dump(exclude_none=True),
+                headers={"Authorization": f"Bearer {self.api_key}"},
+            )
+            create_response.raise_for_status()
+            self.processor = V1Processor.model_validate(create_response.json())
+            print(f"Created Processor {self.processor.metadata.name}")
+        else:
+            # Else, update
+            print(
+                f"Found Processor {self.processor.metadata.name}, updating if necessary"
+            )
+
+            update_processor = V1UpdateProcessor(
+                stream=stream,
+                container=container,
+                schema_=schema_,
+                common_schema=common_schema,
+                min_replicas=min_replicas,
+                max_replicas=max_replicas,
+                scale=scale_config,
+                no_delete=no_delete,
+            )
+
+            print("Update request:")
+            print(update_processor.model_dump(exclude_none=True))
+            patch_response = requests.patch(
+                f"{self.processors_url}/{self.processor.metadata.namespace}/{self.processor.metadata.name}",
+                json=update_processor.model_dump(exclude_none=True),
+                headers={"Authorization": f"Bearer {self.api_key}"},
+            )
+            patch_response.raise_for_status()
+            print(f"Updated Processor {self.processor.metadata.name}")
+
+    def send(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Send data to the processor.
+        """
+        if not self.processor or not self.processor.metadata.name:
+            raise ValueError("Processor not found")
+
+        url = f"{self.processors_url}/{self.processor.metadata.namespace}/{self.processor.metadata.name}/send"
+
+        response = requests.get(
+            url,
+            params=data,
+            headers={"Authorization": f"Bearer {self.api_key}"},
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def scale(self, replicas: int) -> Dict[str, Any]:
+        """
+        Scale the processor.
+        """
+        if not self.processor or not self.processor.metadata.name:
+            raise ValueError("Processor not found")
+
+        url = f"{self.processors_url}/{self.processor.metadata.namespace}/{self.processor.metadata.name}/scale"
+        scale_request = V1ProcessorScaleRequest(replicas=replicas)
+
+        response = requests.post(
+            url,
+            json=scale_request.model_dump(exclude_none=True),
+            headers={"Authorization": f"Bearer {self.api_key}"},
+        )
+        response.raise_for_status()
+        return response.json()
+
+    @classmethod
+    def load(
+        cls,
+        name: str,
+        namespace: Optional[str] = None,
+        config: Optional[GlobalConfig] = None,
+    ):
+        """
+        Get a Processor from the remote server.
+        """
+        processors = cls.get(namespace=namespace, name=name, config=config)
+        if not processors:
+            raise ValueError("Processor not found")
+        processor_v1 = processors[0]
+
+        out = cls.__new__(cls)
+        out.processor = processor_v1
+        out.config = config or GlobalConfig.read()
+        if not out.config:
+            raise ValueError("No config found")
+        out.current_server = out.config.get_current_server_config()
+        if not out.current_server:
+            raise ValueError("No server config found")
+        out.api_key = out.current_server.api_key
+        out.orign_host = out.current_server.server
+        out.processors_url = f"{out.orign_host}/v1/processors"
+        out.name = name
+        out.namespace = namespace
+
+        # Set specific fields from the processor
+        out.stream = processor_v1.stream
+        out.container = processor_v1.container
+        out.schema_ = processor_v1.schema_
+        out.common_schema = processor_v1.common_schema
+        out.min_replicas = processor_v1.min_replicas
+        out.max_replicas = processor_v1.max_replicas
+        out.scale_config = processor_v1.scale
+
+        return out
+
+    @classmethod
+    def get(
+        cls,
+        name: Optional[str] = None,
+        namespace: Optional[str] = None,
+        config: Optional[GlobalConfig] = None,
+    ) -> List[V1Processor]:
+        """
+        Get a list of Processors that match the optional name and/or namespace filters.
+        """
+        config = config or GlobalConfig.read()
+        if not config:
+            raise ValueError("No config found")
+        current_server = config.get_current_server_config()
+        if not current_server:
+            raise ValueError("No server config found")
+        processors_url = f"{current_server.server}/v1/processors"
+
+        response = requests.get(
+            processors_url,
+            headers={"Authorization": f"Bearer {current_server.api_key}"},
+        )
+        response.raise_for_status()
+
+        processors_response = V1Processors.model_validate(response.json())
+        filtered_processors = processors_response.processors
+
+        if name:
+            filtered_processors = [
+                p for p in filtered_processors if p.metadata.name == name
+            ]
+        if namespace:
+            filtered_processors = [
+                p for p in filtered_processors if p.metadata.namespace == namespace
+            ]
+
+        return filtered_processors
+
+    def delete(self):
+        """
+        Delete the Processor.
+        """
+        if not self.processor or not self.processor.metadata.name:
+            raise ValueError("Processor not found")
+
+        url = f"{self.processors_url}/{self.processor.metadata.namespace}/{self.processor.metadata.name}"
+        response = requests.delete(
+            url, headers={"Authorization": f"Bearer {self.api_key}"}
+        )
+        response.raise_for_status()
+        return
+
+    def ref(self) -> str:
+        """
+        Get the resource ref for the processor.
+        """
+        return f"{self.name}.{self.namespace}.Processor"

{nebu-0.1.7.dist-info → nebu-0.1.9.dist-info}/METADATA

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

nebu-0.1.9.dist-info/RECORD

@@ -0,0 +1,20 @@
+nebu/__init__.py,sha256=EbdC8ZKnRTt6jkX0WN0p1pnaDEzb2InqZ1r8QZWzph0,195
+nebu/auth.py,sha256=rApCd-7_c3GpIb7gjCB79rR7SOcmkG7MmaTE6zMbvr0,1125
+nebu/config.py,sha256=XBY7uKgcJX9d1HGxqqpx87o_9DuF3maUlUnKkcpUrKU,4565
+nebu/meta.py,sha256=CzFHMND9seuewzq9zNNx9WTr6JvrCBExe7BLqDSr7lM,745
+nebu/containers/container.py,sha256=yb7KaPTVXnEEAlrpdlUi4HNqF6P7z9bmwAILGlq6iqU,13502
+nebu/containers/decorator.py,sha256=qiM7hbHne9MhSp1gDgX5z5bimsXr_YPjTIZoe09dwr4,2741
+nebu/containers/models.py,sha256=0j6NGy4yto-enRDh_4JH_ZTbHrLdSpuMOqNQPnIrwC4,6815
+nebu/containers/server.py,sha256=yFa2Y9PzBn59E1HftKiv0iapPonli2rbGAiU6r-wwe0,2513
+nebu/processors/consumer.py,sha256=rFqd6gg2OYgXi3gf11GFpuaOOzuK1TYaPO-t_leSR8Y,15097
+nebu/processors/decorate.py,sha256=8jemT7QvY-2aAJAOiYzjClja-Zso0QgWXZH377uIW4I,13126
+nebu/processors/default.py,sha256=W4slJenG59rvyTlJ7gRp58eFfXcNOTT2Hfi6zzJAobI,365
+nebu/processors/models.py,sha256=ZCHSXYZzdiMvhvCdi1y3lvD63oUOv8xIp5ncPaepibw,4223
+nebu/processors/processor.py,sha256=oy2YdI-cy6qQWxrZhpZahJV46oWZlu_Im-jm811R_oo,9667
+nebu/redis/models.py,sha256=coPovAcVXnOU1Xh_fpJL4PO3QctgK9nBe5QYoqEcnxg,1230
+nebu/services/service.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nebu-0.1.9.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+nebu-0.1.9.dist-info/METADATA,sha256=h6OCHxCdApdiQongRaRCFRxxFbLXfSraoDyLt_MGu_s,1587
+nebu-0.1.9.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+nebu-0.1.9.dist-info/top_level.txt,sha256=uLIbEKJeGSHWOAJN5S0i5XBGwybALlF9bYoB1UhdEgQ,5
+nebu-0.1.9.dist-info/RECORD,,

nebu-0.1.7.dist-info/RECORD

@@ -1,16 +0,0 @@
-nebu/__init__.py,sha256=EbdC8ZKnRTt6jkX0WN0p1pnaDEzb2InqZ1r8QZWzph0,195
-nebu/config.py,sha256=XBY7uKgcJX9d1HGxqqpx87o_9DuF3maUlUnKkcpUrKU,4565
-nebu/meta.py,sha256=CzFHMND9seuewzq9zNNx9WTr6JvrCBExe7BLqDSr7lM,745
-nebu/containers/container.py,sha256=yb7KaPTVXnEEAlrpdlUi4HNqF6P7z9bmwAILGlq6iqU,13502
-nebu/containers/decorator.py,sha256=qiM7hbHne9MhSp1gDgX5z5bimsXr_YPjTIZoe09dwr4,2741
-nebu/containers/models.py,sha256=_d6BS6puoVWvyHhWX-74WFHJSOE8WJaFt2zGMTm9EEA,6782
-nebu/containers/server.py,sha256=yFa2Y9PzBn59E1HftKiv0iapPonli2rbGAiU6r-wwe0,2513
-nebu/processors/models.py,sha256=6XSw4iM77XYJf6utm8QReN9fyMS0dK40a5sVwsC7RRA,1970
-nebu/processors/processor.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nebu/redis/models.py,sha256=coPovAcVXnOU1Xh_fpJL4PO3QctgK9nBe5QYoqEcnxg,1230
-nebu/services/service.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nebu-0.1.7.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-nebu-0.1.7.dist-info/METADATA,sha256=1tmqknTkrPQ-Q5qiK2T420II-fBLSN0-1gPYbZLoL1o,1587
-nebu-0.1.7.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-nebu-0.1.7.dist-info/top_level.txt,sha256=uLIbEKJeGSHWOAJN5S0i5XBGwybALlF9bYoB1UhdEgQ,5
-nebu-0.1.7.dist-info/RECORD,,