nebu 0.1.99__py3-none-any.whl → 0.1.100__py3-none-any.whl

nebu/processors/decorate.py

@@ -396,7 +396,68 @@ def processor(
     hot_reload: bool = True,
     debug: bool = False,
     name: Optional[str] = None,
+    wait_for_healthy: bool = False,
 ):
+    """
+    Decorator that creates a processor from a function.
+
+    This decorator transforms a function into a distributed processor that can be
+    deployed and executed remotely. The function code is uploaded to S3 and a
+    containerized processor is created.
+
+    Args:
+        image: Container image to use for the processor
+        setup_script: Optional script to run during container setup
+        scale: Scaling configuration for the processor
+        min_replicas: Minimum number of processor replicas
+        max_replicas: Maximum number of processor replicas
+        platform: Target platform for container deployment
+        accelerators: List of accelerators (e.g., GPUs) to request
+        namespace: Kubernetes namespace for the processor
+        labels: Additional labels to apply to the processor
+        env: Environment variables to set in the container
+        volumes: Volume mounts for the container
+        resources: Resource requests and limits
+        meters: Billing/metering configuration
+        authz: Authorization configuration
+        python_cmd: Python command to use (default: "python")
+        no_delete: Whether to prevent deletion of the processor
+        include: List of objects to include in the processor environment
+        init_func: Optional initialization function to run once
+        queue: Message queue configuration
+        timeout: Processor timeout configuration
+        ssh_keys: SSH keys for secure access
+        ports: Port configurations for the container
+        proxy_port: Proxy port configuration
+        health_check: Container health check configuration
+        execution_mode: Execution mode ("inline" or "subprocess")
+        config: Global configuration override
+        hot_reload: Enable/disable hot code reloading (default: True)
+        debug: Enable debug mode
+        name: Override processor name (defaults to function name)
+        wait_for_healthy: If True, wait for the processor to become healthy
+                         before the decorator returns (default: False)
+
+    Returns:
+        Processor: A Processor instance wrapping the decorated function
+
+    Example:
+        ```python
+        @processor(
+            image="python:3.11",
+            setup_script="pip install numpy",
+            wait_for_healthy=True
+        )
+        def my_processor(data: Message[InputModel]) -> OutputModel:
+            return OutputModel(result=data.content.value * 2)
+        ```
+
+    Note:
+        When wait_for_healthy=True, the decorator will send health check messages
+        to the processor and wait for successful responses before returning. This
+        ensures the processor is ready to accept requests but may add startup time.
+    """
+
     def decorator(
         func: Callable[[Any], Any],
     ) -> Processor:
@@ -1208,6 +1269,7 @@ def processor(
             max_replicas=max_replicas,
             scale_config=scale,
             no_delete=no_delete,
+            wait_for_healthy=wait_for_healthy,
         )
         logger.debug(
             f"Decorator: Processor instance '{processor_name}' created successfully."

nebu/processors/processor.py

@@ -1,6 +1,8 @@
 import json
 import threading
-from typing import Any, Dict, Generic, List, Optional, TypeVar
+import time
+import uuid
+from typing import Any, Dict, Generic, List, Optional, TypeVar, cast
 
 import requests
 from pydantic import BaseModel
@@ -107,6 +109,7 @@ class Processor(Generic[InputType, OutputType]):
         config: Optional[GlobalConfig] = None,
         api_key: Optional[str] = None,
         no_delete: bool = False,
+        wait_for_healthy: bool = False,
     ):
         self.config = config or GlobalConfig.read()
         if not self.config:
@@ -208,6 +211,10 @@ class Processor(Generic[InputType, OutputType]):
             self.processor = V1Processor.model_validate(patch_response.json())
             logger.info(f"Updated Processor {self.processor.metadata.name}")
 
+        # --- Wait for health check if requested ---
+        if wait_for_healthy:
+            self._wait_for_health_check()
+
     def __call__(
         self,
         data: InputType,
@@ -230,6 +237,7 @@ class Processor(Generic[InputType, OutputType]):
         logs: bool = False,
         api_key: Optional[str] = None,
         user_key: Optional[str] = None,
+        timeout: Optional[float] = 600.0,
     ) -> OutputType | Dict[str, Any] | None:
         """
         Send data to the processor and optionally stream logs in the background.
@@ -260,6 +268,7 @@ class Processor(Generic[InputType, OutputType]):
             messages_url,
             json=stream_data.model_dump(mode="json", exclude_none=True),
             headers={"Authorization": f"Bearer {api_key}"},
+            timeout=timeout,
         )
         response.raise_for_status()
         send_response_json = response.json()
@@ -432,3 +441,64 @@ class Processor(Generic[InputType, OutputType]):
             self._log_thread = None
         else:
             logger.info(f"No active log stream to stop for {self.name}.")
+
+    def _wait_for_health_check(
+        self, timeout: float = 300.0, retry_interval: float = 5.0
+    ) -> None:
+        """
+        Wait for the processor to respond to health checks.
+
+        Args:
+            timeout: Maximum time to wait for health check in seconds
+            retry_interval: Time between health check attempts in seconds
+        """
+        if not self.processor or not self.processor.metadata.name:
+            raise ValueError("Processor not found, cannot perform health check")
+
+        logger.info(
+            f"Waiting for processor {self.processor.metadata.name} to be healthy..."
+        )
+
+        start_time = time.time()
+        while time.time() - start_time < timeout:
+            try:
+                # Create a health check message
+                health_check_data = {
+                    "kind": "HealthCheck",
+                    "id": str(uuid.uuid4()),
+                    "content": {},
+                    "created_at": time.time(),
+                }
+
+                # Send health check and wait for response
+                response = self.send(
+                    data=cast(InputType, health_check_data),
+                    wait=True,
+                    timeout=30.0,  # Short timeout for individual health check
+                )
+
+                # Check if the response indicates health
+                if response and isinstance(response, dict):
+                    status = response.get("status")
+                    content = response.get("content", {})
+                    if status == "success" and content.get("status") == "healthy":
+                        logger.info(
+                            f"Processor {self.processor.metadata.name} is healthy!"
+                        )
+                        return
+
+                logger.debug(
+                    f"Health check attempt failed, retrying in {retry_interval}s..."
+                )
+
+            except Exception as e:
+                logger.debug(
+                    f"Health check failed with error: {e}, retrying in {retry_interval}s..."
+                )
+
+            time.sleep(retry_interval)
+
+        # If we get here, we timed out
+        raise TimeoutError(
+            f"Processor {self.processor.metadata.name} failed to become healthy within {timeout} seconds"
+        )

{nebu-0.1.99.dist-info → nebu-0.1.100.dist-info}/METADATA

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

{nebu-0.1.99.dist-info → nebu-0.1.100.dist-info}/RECORD

@@ -15,14 +15,14 @@ nebu/namespaces/models.py,sha256=EqUOpzhVBhvJw2P92ONDUbIgC31M9jMmcaG5vyOrsWg,497
 nebu/namespaces/namespace.py,sha256=oeZyGqsIGIrppyjif1ZONsdTmqRgd9oSLFE1BChXTTE,5247
 nebu/processors/consumer.py,sha256=j6iKF_wc8RUNKrFqjB5keUX-Gj9hGZUbmAjEyTm-Oj0,55367
 nebu/processors/consumer_process_worker.py,sha256=h--eNFKaLbUayxn88mB8oGGdrU2liE1dnwm_TPlewX8,36960
-nebu/processors/decorate.py,sha256=OgUVpYx0E3bcBocdPPuE1YLg-PAChWbODqUKDIm6jUY,55852
+nebu/processors/decorate.py,sha256=AfHVCoNbW7RymccF5ewleEL-GlMiqVH1-t9bCmD60rk,58654
 nebu/processors/default.py,sha256=cy4ETMdbdRGkrvbYec1o60h7mGDlGN5JsuUph0ENtDU,364
 nebu/processors/models.py,sha256=g4B1t6Rgoy-NUEHBLeQc0EENzHXLDlWSio8Muv7cTDU,4093
-nebu/processors/processor.py,sha256=xxduD632g_2lBhAF2tZ3g0aoZJFgbfNwrDgtOAio0Is,16677
+nebu/processors/processor.py,sha256=Njy32S0r77K4ww1D5U0dhD0vgTyJSMQztKwpkzHwLwg,19250
 nebu/redis/models.py,sha256=coPovAcVXnOU1Xh_fpJL4PO3QctgK9nBe5QYoqEcnxg,1230
 nebu/services/service.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nebu-0.1.99.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-nebu-0.1.99.dist-info/METADATA,sha256=UG1YcDv7m2VoOK4gQqtNOveUHIEijLwc323vSwePSNI,1797
-nebu-0.1.99.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
-nebu-0.1.99.dist-info/top_level.txt,sha256=uLIbEKJeGSHWOAJN5S0i5XBGwybALlF9bYoB1UhdEgQ,5
-nebu-0.1.99.dist-info/RECORD,,
+nebu-0.1.100.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+nebu-0.1.100.dist-info/METADATA,sha256=5Kp2Ce9vAVCX7ugzOzanWWHZHErMvmntkH1nYfml6WU,1798
+nebu-0.1.100.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+nebu-0.1.100.dist-info/top_level.txt,sha256=uLIbEKJeGSHWOAJN5S0i5XBGwybALlF9bYoB1UhdEgQ,5
+nebu-0.1.100.dist-info/RECORD,,