nebu 0.1.0__py3-none-any.whl → 0.1.3__py3-none-any.whl

nebu/containers/container.py

@@ -220,6 +220,7 @@ class Container:
         self.queue = queue
         self.timeout = timeout
         self.ssh_keys = ssh_keys
+        self.status = self.container.status
 
     @classmethod
     def from_request(cls, request: V1ContainerRequest) -> V1Container:

nebu/containers/decorator.py

@@ -0,0 +1,174 @@
+import base64
+import inspect
+import pickle
+import time
+from typing import Any, Callable, List, Optional
+
+import requests
+
+from nebu.containers.container import Container
+from nebu.containers.models import V1ContainerRequest, V1EnvVar, V1ResourceMetaRequest
+
+
+def container(
+    image: str,
+    name: Optional[str] = None,
+    namespace: str = "default",
+    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
+            func_code = inspect.getsource(func)
+
+            # 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
+
+
+def on_feedback(
+    human: Human,
+    accelerators: Optional[List[str]] = None,
+    platform: str = "runpod",
+    python_cmd: str = "python",
+    timeout: Optional[str] = None,
+    env: Optional[List[V1EnvVar]] = None,
+):
+    def decorator(func: Callable):
+        nonlocal name
+        if name is None:
+            name = func.__name__
+
+        # Get function source code
+        func_code = inspect.getsource(func)
+
+        command = """
+
+"""
+
+        # Create the container request
+        container_request = V1ContainerRequest(
+            kind="Container",
+            platform=platform,
+            metadata=V1ResourceMetaRequest(
+                name=name,
+                namespace=namespace,
+            ),
+            image=image,
+            env=env,
+            command=f"{python_cmd} -m nebu.containers.server",
+            accelerators=accelerators,
+            timeout=timeout,
+            proxy_port=8080,
+            restart="Never",  # Jobs should not restart
+        )
+
+        def run(*args: Any, **kwargs: Any):
+            # Create a container from the request
+            cont = Container.from_request(container_request)
+
+            # Wait for container to be running
+            while (
+                cont.status
+                and cont.status.status
+                and cont.status.status.lower() != "running"
+            ):
+                print(f"Job '{cont.metadata.name}' not running yet; waiting...")
+                time.sleep(1)
+
+            # 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
+
+        # Attach the run method to the container request
+        container_request.run = run  # type: ignore
+
+        return container_request
+
+    return decorator

nebu/containers/models.py

@@ -1,7 +1,7 @@
 from enum import Enum
 from typing import Dict, List, Optional
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, ConfigDict, Field
 
 from nebu.meta import V1ResourceMeta, V1ResourceMetaRequest
 
@@ -59,17 +59,21 @@ class V1VolumePath(BaseModel):
     continuous: bool = False
     driver: V1VolumeDriver = V1VolumeDriver.RCLONE_SYNC
 
+    model_config = ConfigDict(use_enum_values=True)
+
 
 class V1VolumeConfig(BaseModel):
     paths: List[V1VolumePath]
     cache_dir: str = "/nebu/cache"
 
+    model_config = ConfigDict(use_enum_values=True)
+
 
 class V1ContainerStatus(BaseModel):
     status: Optional[str] = None
     message: Optional[str] = None
     accelerator: Optional[str] = None
-    public_ip: Optional[str] = None
+    tailnet_url: Optional[str] = None
     cost_per_hr: Optional[float] = None
 
 
@@ -112,6 +116,16 @@ class V1AuthzConfig(BaseModel):
     rules: Optional[List[V1AuthzRule]] = None
 
 
+class V1ContainerHealthCheck(BaseModel):
+    interval: Optional[str] = None
+    timeout: Optional[str] = None
+    retries: Optional[int] = None
+    start_period: Optional[str] = None
+    path: Optional[str] = None
+    port: Optional[int] = None
+    protocol: Optional[str] = None
+
+
 class V1PortRequest(BaseModel):
     port: int
     protocol: Optional[str] = None
@@ -142,6 +156,9 @@ class V1ContainerRequest(BaseModel):
     ports: Optional[List[V1PortRequest]] = None
     proxy_port: Optional[int] = None
     authz: Optional[V1AuthzConfig] = None
+    health_check: Optional[V1ContainerHealthCheck] = None
+
+    model_config = ConfigDict(use_enum_values=True)
 
 
 class V1Container(BaseModel):
@@ -163,6 +180,9 @@ class V1Container(BaseModel):
     ports: Optional[List[V1Port]] = None
     proxy_port: Optional[int] = None
     authz: Optional[V1AuthzConfig] = None
+    health_check: Optional[V1ContainerHealthCheck] = None
+
+    model_config = ConfigDict(use_enum_values=True)
 
 
 class V1UpdateContainer(BaseModel):
@@ -181,7 +201,14 @@ class V1UpdateContainer(BaseModel):
     timeout: Optional[str] = None
     resources: Optional[V1ContainerResources] = None
     proxy_port: Optional[int] = None
+    authz: Optional[V1AuthzConfig] = None
+    health_check: Optional[V1ContainerHealthCheck] = None
+    no_delete: Optional[bool] = None
+
+    model_config = ConfigDict(use_enum_values=True)
 
 
 class V1Containers(BaseModel):
     containers: List[V1Container]
+
+    model_config = ConfigDict(use_enum_values=True)

nebu/containers/server.py

@@ -0,0 +1,70 @@
+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-0.1.0.dist-info → nebu-0.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nebu
-Version: 0.1.0
+Version: 0.1.3
 Summary: A globally distributed container runtime
 Requires-Python: >=3.10.14
 Description-Content-Type: text/markdown
@@ -12,7 +12,8 @@ Requires-Dist: requests>=2.32.3
 Dynamic: license-file
 
 # nebulous-py
-A python library for the [Nebulous runtime](https://github.com/agentsea/nebulous)
+
+A declarative python library for the [Nebulous runtime](https://github.com/agentsea/nebulous)
 
 ## Installation
 
@@ -22,14 +23,14 @@ pip install nebu
 
 ## Usage
 
+Create a pytorch container on runpod with 1 A100 GPU
+
 ```python
-from nebu import Container, V1EnvVar, V1ResourceMeta
+from nebu import Container, V1EnvVar
 
 container = Container(
-    metadata=V1ResourceMeta(
-        name="pytorch-example",
-        namespace="test",
-    ),
+    name="pytorch-example",
+    namespace="test",
     image="pytorch/pytorch:latest",
     platform="runpod",
     env=[V1EnvVar(name="MY_ENV_VAR", value="my-value")],
@@ -47,6 +48,21 @@ print(f"Container '{container.metadata.name}' is running")
 print(f"You can access the container at {container.status.tailnet_url}")
 ```
 
+### Decorator
+
+Run a python function in a container [in progress]
+
+```python
+from nebu import container
+
+@container(image="python:3.10-slim", accelerators=["1:A100_SXM"])
+def my_function(x: int, y: int) -> int:
+    return x + y
+
+result = my_function(1, 2)
+print(result)
+```
+
 ## Contributing
 
 Please open an issue or a PR to contribute to the project.

nebu-0.1.3.dist-info/RECORD

@@ -0,0 +1,16 @@
+nebu/__init__.py,sha256=EbdC8ZKnRTt6jkX0WN0p1pnaDEzb2InqZ1r8QZWzph0,195
+nebu/config.py,sha256=XBY7uKgcJX9d1HGxqqpx87o_9DuF3maUlUnKkcpUrKU,4565
+nebu/meta.py,sha256=AnvrtP0mc7a-YP4zVhErHPsU0FSmwMejYgKWnV8wqqE,566
+nebu/containers/container.py,sha256=WCXBadAHhvkFQdpDjHu7nh6NjLlMxRsJbMbLXH8zaCs,9283
+nebu/containers/decorator.py,sha256=sZQ4ZwqQk_jLDJ-n9P6N0MlxvWL9Ac7eCPIHVxYq58c,5576
+nebu/containers/models.py,sha256=o4jHBiXpcnxdxvUSR4q38ctHdL0w6M0uRj4DD-5B0o8,5932
+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.3.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+nebu-0.1.3.dist-info/METADATA,sha256=QAQ6mgaNa41T-MxXPykyYFibeki6AUZw1kNPoWQHPHo,1587
+nebu-0.1.3.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+nebu-0.1.3.dist-info/top_level.txt,sha256=uLIbEKJeGSHWOAJN5S0i5XBGwybALlF9bYoB1UhdEgQ,5
+nebu-0.1.3.dist-info/RECORD,,

nebu-0.1.0.dist-info/RECORD

@@ -1,14 +0,0 @@
-nebu/__init__.py,sha256=EbdC8ZKnRTt6jkX0WN0p1pnaDEzb2InqZ1r8QZWzph0,195
-nebu/config.py,sha256=XBY7uKgcJX9d1HGxqqpx87o_9DuF3maUlUnKkcpUrKU,4565
-nebu/meta.py,sha256=AnvrtP0mc7a-YP4zVhErHPsU0FSmwMejYgKWnV8wqqE,566
-nebu/containers/container.py,sha256=cE8BChcsHXAtpvaP7w62mMQmHq8y7U-ssKtxS-kQ0CQ,9239
-nebu/containers/models.py,sha256=yJerkN7V03s_V5Yr3WdMghzlj3kLpawousGy5UElxJ4,5065
-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.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-nebu-0.1.0.dist-info/METADATA,sha256=noow9VAkFgyhZIRUZJcaZUtB1wULdyU1Inmm5nuMPM4,1305
-nebu-0.1.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-nebu-0.1.0.dist-info/top_level.txt,sha256=uLIbEKJeGSHWOAJN5S0i5XBGwybALlF9bYoB1UhdEgQ,5
-nebu-0.1.0.dist-info/RECORD,,