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

nebu/processors/processor.py

@@ -6,6 +6,7 @@ import requests
 from pydantic import BaseModel
 
 from nebu.config import GlobalConfig
+from nebu.logging import logger
 from nebu.meta import V1ResourceMetaRequest, V1ResourceReference
 from nebu.processors.models import (
     V1ContainerRequest,
@@ -26,11 +27,13 @@ def _fetch_and_print_logs(log_url: str, api_key: str, processor_name: str):
     """Helper function to fetch logs in a separate thread."""
     try:
         headers = {"Authorization": f"Bearer {api_key}"}
-        print(f"--- Attempting to stream logs for {processor_name} from {log_url} ---")
+        logger.info(
+            f"--- Attempting to stream logs for {processor_name} from {log_url} ---"
+        )
         # Use stream=True for potentially long-lived connections and timeout
         with requests.get(log_url, headers=headers, stream=True, timeout=300) as r:
             r.raise_for_status()
-            print(f"--- Streaming logs for {processor_name} ---")
+            logger.info(f"--- Streaming logs for {processor_name} ---")
             for line in r.iter_lines():
                 if not line:
                     continue
@@ -45,37 +48,42 @@ def _fetch_and_print_logs(log_url: str, api_key: str, processor_name: str):
                         for container, log_content in log_data.items():
                             # Ensure log_content is a string before printing
                             if isinstance(log_content, str):
-                                print(f"[{processor_name}][{container}] {log_content}")
+                                logger.info(
+                                    f"[{processor_name}][{container}] {log_content}"
+                                )
                             else:
                                 # Handle cases where log_content might not be a string
-                                print(
+                                logger.warning(
                                     f"[{processor_name}][{container}] Unexpected log format: {log_content}"
                                 )
                     else:
                         # If not a dict, print the raw line with a warning
-                        print(
+                        logger.warning(
                             f"[{processor_name}] Unexpected log structure (not a dict): {decoded_line}"
                         )
 
                 except json.JSONDecodeError:
                     # If JSON parsing fails, print the original line as fallback
-                    print(f"[{processor_name}] {line.decode('utf-8')} (raw/non-JSON)")
+                    logger.warning(
+                        f"[{processor_name}] {line.decode('utf-8')} (raw/non-JSON)"
+                    )
                 except Exception as e:
                     # Catch other potential errors during line processing
-                    print(f"Error processing log line for {processor_name}: {e}")
+                    logger.error(f"Error processing log line for {processor_name}: {e}")
 
-        print(f"--- Log stream ended for {processor_name} ---")
+        logger.info(f"--- Log stream ended for {processor_name} ---")
     except requests.exceptions.Timeout:
-        print(f"Log stream connection timed out for {processor_name}.")
+        logger.warning(f"Log stream connection timed out for {processor_name}.")
     except requests.exceptions.RequestException as e:
         # Handle potential API errors gracefully
-        print(f"Error fetching logs for {processor_name} from {log_url}: {e}")
+        logger.error(f"Error fetching logs for {processor_name} from {log_url}: {e}")
         if e.response is not None:
-            print(
+            # Log response details at a debug level or keep as error if critical
+            logger.error(
                 f"Response status: {e.response.status_code}, Response body: {e.response.text}"
             )
     except Exception as e:
-        print(
+        logger.error(
             f"An unexpected error occurred while fetching logs for {processor_name}: {e}"
         )
 
@@ -130,10 +138,10 @@ class Processor(Generic[InputType, OutputType]):
         if not namespace:
             namespace = "-"
 
-        print(f"Using namespace: {namespace}")
+        logger.info(f"Using namespace: {namespace}")
 
         existing_processors = V1Processors.model_validate(response.json())
-        print(f"Existing processors: {existing_processors}")
+        logger.debug(f"Existing processors: {existing_processors}")
         self.processor: Optional[V1Processor] = next(
             (
                 processor_val
@@ -143,11 +151,11 @@ class Processor(Generic[InputType, OutputType]):
             ),
             None,
         )
-        print(f"Processor: {self.processor}")
+        logger.debug(f"Processor: {self.processor}")
 
         # If not found, create
         if not self.processor:
-            print("Creating processor")
+            logger.info("Creating processor")
             # Create metadata and processor request
             metadata = V1ResourceMetaRequest(
                 name=name, namespace=namespace, labels=labels
@@ -163,8 +171,8 @@ class Processor(Generic[InputType, OutputType]):
                 scale=scale_config,
             )
 
-            print("Request:")
-            print(processor_request.model_dump(exclude_none=True))
+            logger.debug("Request:")
+            logger.debug(processor_request.model_dump(exclude_none=True))
             create_response = requests.post(
                 self.processors_url,
                 json=processor_request.model_dump(exclude_none=True),
@@ -172,10 +180,10 @@ class Processor(Generic[InputType, OutputType]):
             )
             create_response.raise_for_status()
             self.processor = V1Processor.model_validate(create_response.json())
-            print(f"Created Processor {self.processor.metadata.name}")
+            logger.info(f"Created Processor {self.processor.metadata.name}")
         else:
             # Else, update
-            print(
+            logger.info(
                 f"Found Processor {self.processor.metadata.name}, updating if necessary"
             )
 
@@ -189,8 +197,8 @@ class Processor(Generic[InputType, OutputType]):
                 no_delete=no_delete,
             )
 
-            print("Update request:")
-            print(update_processor.model_dump(exclude_none=True))
+            logger.debug("Update request:")
+            logger.debug(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),
@@ -198,7 +206,7 @@ class Processor(Generic[InputType, OutputType]):
             )
             patch_response.raise_for_status()
             self.processor = V1Processor.model_validate(patch_response.json())
-            print(f"Updated Processor {self.processor.metadata.name}")
+            logger.info(f"Updated Processor {self.processor.metadata.name}")
 
     def __call__(
         self,
@@ -264,14 +272,16 @@ class Processor(Generic[InputType, OutputType]):
                 )
                 try:
                     self._log_thread.start()
-                    print(f"Started background log fetching for {processor_name}...")
+                    logger.info(
+                        f"Started background log fetching for {processor_name}..."
+                    )
                 except Exception as e:
-                    print(
+                    logger.error(
                         f"Failed to start log fetching thread for {processor_name}: {e}"
                     )
                     self._log_thread = None  # Reset if start fails
             else:
-                print(f"Log fetching is already running for {processor_name}.")
+                logger.info(f"Log fetching is already running for {processor_name}.")
 
         return send_response_json
 
@@ -411,9 +421,9 @@ class Processor(Generic[InputType, OutputType]):
             # Setting the reference to None allows a new thread to be created if needed.
             # The OS will eventually clean up the daemon thread when the main process exits,
             # or potentially sooner if the network request completes or errors out.
-            print(
+            logger.info(
                 f"Disassociating from active log stream for {self.name}. A new stream can be started."
             )
             self._log_thread = None
         else:
-            print(f"No active log stream to stop for {self.name}.")
+            logger.info(f"No active log stream to stop for {self.name}.")

{nebu-0.1.91.dist-info → nebu-0.1.93.dist-info}/METADATA

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: nebu
-Version: 0.1.91
+Version: 0.1.93
 Summary: A globally distributed container runtime
 Requires-Python: >=3.10.14
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: boto3>=1.37.30
 Requires-Dist: dill>=0.3.8
+Requires-Dist: loguru>=0.7.3
 Requires-Dist: openai>=1.68.2
 Requires-Dist: pillow>=10.4.0
 Requires-Dist: pydantic>=2.10.6

nebu-0.1.93.dist-info/RECORD

@@ -0,0 +1,28 @@
+nebu/__init__.py,sha256=xNtWiN29MJZK_WBEUP-9hDmlkfLxoASVI-f4tNTXO58,454
+nebu/auth.py,sha256=N_v6SPFD9HU_UoRDTaouH03g2Hmo9C-xxqInE1FweXE,1471
+nebu/cache.py,sha256=JqRb4FdZrRrO4ePlwvsKdxRC8dNEFMxfTWag0aJz8Gw,4893
+nebu/config.py,sha256=C5Jt9Bd0i0HrgzBSVNJ-Ml3KwX_gaYbYYZEtNL2gvJg,7031
+nebu/data.py,sha256=randOsFQxOQdw7Yhg7mb6PvH5Efjfc-KpvqdBdpWTEE,40923
+nebu/errors.py,sha256=bBnK5YQ6qZg4OMY81AN2k03ppefg89FUwF_SHEMlqCA,170
+nebu/logging.py,sha256=VzpjCEoXm3c4i0sKJL5GTsPIhTQ6Y4BPUTzPmwhve7o,950
+nebu/meta.py,sha256=CzFHMND9seuewzq9zNNx9WTr6JvrCBExe7BLqDSr7lM,745
+nebu/orign.py,sha256=SkVfHgpadwik58KCZCrjdV5EHY0dhpEhDvijzLxY11Y,2052
+nebu/builders/builder.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nebu/builders/models.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nebu/containers/container.py,sha256=Mrh_gvMsTvDkj3CwpqIPzJ72IMw0gQIg64y548vq0yg,13803
+nebu/containers/models.py,sha256=0j6NGy4yto-enRDh_4JH_ZTbHrLdSpuMOqNQPnIrwC4,6815
+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=pGA0m8cxTnEu7ullKTaAgjf_FFP5RhRqBnQnsdSwtJs,55476
+nebu/processors/default.py,sha256=W4slJenG59rvyTlJ7gRp58eFfXcNOTT2Hfi6zzJAobI,365
+nebu/processors/models.py,sha256=FnBJFxtaJkp-uIOs90qkJUBvOR80l2cdGnfmOIWIvVA,4058
+nebu/processors/processor.py,sha256=dCQ9si_P03Lw_dLQESE_TUD6ZGGTYZce28GmiyWm1Hg,16525
+nebu/redis/models.py,sha256=coPovAcVXnOU1Xh_fpJL4PO3QctgK9nBe5QYoqEcnxg,1230
+nebu/services/service.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nebu-0.1.93.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+nebu-0.1.93.dist-info/METADATA,sha256=3MTAfHaYqznKvUqtvvB_CBslT2Xnh8j1TLWz05ec8PM,1760
+nebu-0.1.93.dist-info/WHEEL,sha256=wXxTzcEDnjrTwFYjLPcsW_7_XihufBwmpiBeiXNBGEA,91
+nebu-0.1.93.dist-info/top_level.txt,sha256=uLIbEKJeGSHWOAJN5S0i5XBGwybALlF9bYoB1UhdEgQ,5
+nebu-0.1.93.dist-info/RECORD,,

nebu/containers/decorator.py

@@ -1,93 +0,0 @@
-import base64
-import pickle
-import time
-from typing import Any, Callable, List, Optional
-
-import dill  # Import dill
-import requests
-
-from nebu.containers.container import Container
-
-
-def container(
-    image: str,
-    name: Optional[str] = None,
-    namespace: Optional[str] = None,
-    accelerators: Optional[List[str]] = None,
-    platform: str = "runpod",
-    python_cmd: str = "python",
-):
-    def decorator(func: Callable):
-        nonlocal name
-        if name is None:
-            name = func.__name__
-
-        def wrapper(*args: Any, **kwargs: Any):
-            nonlocal name
-            # Create your container with the server script
-            cont = Container(
-                name=name,  # type: ignore
-                namespace=namespace,
-                platform=platform,
-                image=image,
-                accelerators=accelerators,
-                # Command to start our function execution server
-                command=f"{python_cmd} -m nebu.containers.server",  # TODO: need to get the server code into the container
-                proxy_port=8080,
-            )
-
-            # Wait for container to be running
-            while (
-                cont.container.status
-                and cont.container.status.status
-                and cont.container.status.status.lower() != "running"
-            ):
-                print(
-                    f"Container '{cont.container.metadata.name}' not running yet; waiting..."
-                )
-                time.sleep(1)
-
-            # Get function source code using dill
-            try:
-                func_code = dill.source.getsource(func)
-            except (OSError, TypeError) as e:
-                raise RuntimeError(
-                    f"Failed to retrieve source code for function '{func.__name__}'. "
-                    "This can happen with functions defined dynamically or interactively "
-                    "(e.g., in a Jupyter notebook or REPL). Ensure the function is defined "
-                    f"in a standard Python module if possible. Original error: {e}"
-                )
-
-            # Serialize arguments using pickle for complex objects
-            serialized_args = base64.b64encode(pickle.dumps(args)).decode("utf-8")
-            serialized_kwargs = base64.b64encode(pickle.dumps(kwargs)).decode("utf-8")
-
-            # Prepare payload
-            payload = {
-                "function_code": func_code,
-                "args": serialized_args,
-                "kwargs": serialized_kwargs,
-            }
-
-            # Get container URL
-            container_url = (
-                cont.status.tailnet_url
-                if cont.status and hasattr(cont.status, "tailnet_url")
-                else "http://localhost:8080"
-            )
-
-            # Send to container and get result
-            response = requests.post(f"{container_url}/execute", json=payload)
-
-            if response.status_code != 200:
-                raise RuntimeError(f"Function execution failed: {response.text}")
-
-            # Deserialize the result
-            serialized_result = response.json()["result"]
-            result = pickle.loads(base64.b64decode(serialized_result))
-
-            return result
-
-        return wrapper
-
-    return decorator

nebu/containers/server.py

@@ -1,70 +0,0 @@
-import base64
-import json
-import pickle
-from http.server import BaseHTTPRequestHandler, HTTPServer
-
-
-class FunctionExecutionHandler(BaseHTTPRequestHandler):
-    def do_POST(self):
-        content_length = int(self.headers["Content-Length"])
-        post_data = self.rfile.read(content_length)
-        payload = json.loads(post_data.decode("utf-8"))
-
-        if self.path == "/execute":
-            try:
-                # Extract function code, args and kwargs
-                func_code = payload["function_code"]
-                serialized_args = payload["args"]
-                serialized_kwargs = payload["kwargs"]
-
-                # Deserialize arguments
-                args = pickle.loads(base64.b64decode(serialized_args))
-                kwargs = pickle.loads(base64.b64decode(serialized_kwargs))
-
-                # Create a local namespace and execute the function
-                local_namespace = {}
-                exec(func_code, globals(), local_namespace)
-
-                # Find the function object in the local namespace
-                func_name = None
-                for name, obj in local_namespace.items():
-                    if callable(obj) and not name.startswith("__"):
-                        func_name = name
-                        break
-
-                if not func_name:
-                    raise ValueError("No function found in the provided code")
-
-                # Execute the function
-                result = local_namespace[func_name](*args, **kwargs)
-
-                # Serialize the result
-                serialized_result = base64.b64encode(pickle.dumps(result)).decode(
-                    "utf-8"
-                )
-
-                # Send response
-                self.send_response(200)
-                self.send_header("Content-type", "application/json")
-                self.end_headers()
-                self.wfile.write(json.dumps({"result": serialized_result}).encode())
-
-            except Exception as e:
-                self.send_response(500)
-                self.send_header("Content-type", "application/json")
-                self.end_headers()
-                self.wfile.write(json.dumps({"error": str(e)}).encode())
-        else:
-            self.send_response(404)
-            self.end_headers()
-
-
-def run_server(port: int = 8080) -> None:
-    server_address = ("", port)
-    httpd = HTTPServer(server_address, FunctionExecutionHandler)
-    print(f"Starting server on port {port}")
-    httpd.serve_forever()
-
-
-if __name__ == "__main__":
-    run_server()

nebu/processors/remote.py

@@ -1,47 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Any, Dict, Optional, Type, TypeVar
-
-from pydantic import BaseModel
-
-from nebu.config import GlobalConfig
-from nebu.processors.models import V1ContainerRequest, V1Scale
-
-from .models import Message
-from .processor import Processor
-
-I = TypeVar("I", bound=BaseModel)
-O = TypeVar("O", bound=BaseModel)
-
-
-class RemoteProcessor(ABC, Processor):
-    def __init__(
-        self,
-        name: 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,
-    ):
-        super().__init__(
-            name,
-            namespace,
-            labels,
-            container,
-            schema_,
-            common_schema,
-            min_replicas,
-            max_replicas,
-            scale_config,
-            config,
-            no_delete,
-        )
-
-    @abstractmethod
-    def process(self, message: Message[I]) -> Type[BaseModel]:
-        pass

nebu-0.1.91.dist-info/RECORD

@@ -1,30 +0,0 @@
-nebu/__init__.py,sha256=xNtWiN29MJZK_WBEUP-9hDmlkfLxoASVI-f4tNTXO58,454
-nebu/auth.py,sha256=N_v6SPFD9HU_UoRDTaouH03g2Hmo9C-xxqInE1FweXE,1471
-nebu/cache.py,sha256=jmluqvWnE9N8uNq6nppXSxEJK7DKWaB79GicaGg9KmY,4718
-nebu/config.py,sha256=C5Jt9Bd0i0HrgzBSVNJ-Ml3KwX_gaYbYYZEtNL2gvJg,7031
-nebu/data.py,sha256=X0aAJYuHNVcTCRHpIDDm546HwMqIZpv40lGrozlL41A,39797
-nebu/errors.py,sha256=bBnK5YQ6qZg4OMY81AN2k03ppefg89FUwF_SHEMlqCA,170
-nebu/meta.py,sha256=CzFHMND9seuewzq9zNNx9WTr6JvrCBExe7BLqDSr7lM,745
-nebu/orign.py,sha256=SkVfHgpadwik58KCZCrjdV5EHY0dhpEhDvijzLxY11Y,2052
-nebu/builders/builder.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nebu/builders/models.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nebu/containers/container.py,sha256=jyqG-WLFMAFzYLW9Bagi74zJ-zUPq_jHmrxF_2HVWjQ,13652
-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/namespaces/models.py,sha256=EqUOpzhVBhvJw2P92ONDUbIgC31M9jMmcaG5vyOrsWg,497
-nebu/namespaces/namespace.py,sha256=LsbGiGBzVtFUtxCRayGrqr2X1tDzRep4RnNklfWCC1k,5160
-nebu/processors/consumer.py,sha256=RNc4DCuAcmFfSDIyprJrACuVfog6V5cWoqWt3zDRGqQ,53141
-nebu/processors/consumer_process_worker.py,sha256=UAmhrR1wilQnRPbbHYZ9jaIrDKs0LKsSHxbj4VFvFcQ,31969
-nebu/processors/decorate.py,sha256=w8ZJwe8MNhBoW_LJzUWHOgXvo-39RnPsGvRUXSd9Hk4,55784
-nebu/processors/default.py,sha256=W4slJenG59rvyTlJ7gRp58eFfXcNOTT2Hfi6zzJAobI,365
-nebu/processors/models.py,sha256=FnBJFxtaJkp-uIOs90qkJUBvOR80l2cdGnfmOIWIvVA,4058
-nebu/processors/processor.py,sha256=h1ZmD1rqTSuC9QpHkobx6VCUZoVkKXoDBLaB_xxfjys,16037
-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.91.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-nebu-0.1.91.dist-info/METADATA,sha256=LVAMxSj83DGy_CAHMuY1RxH3UYAn2wQ5JSoecIxQeY0,1731
-nebu-0.1.91.dist-info/WHEEL,sha256=wXxTzcEDnjrTwFYjLPcsW_7_XihufBwmpiBeiXNBGEA,91
-nebu-0.1.91.dist-info/top_level.txt,sha256=uLIbEKJeGSHWOAJN5S0i5XBGwybALlF9bYoB1UhdEgQ,5
-nebu-0.1.91.dist-info/RECORD,,