buildfunctions 0.2.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

buildfunctions/http_client.py

@@ -0,0 +1,97 @@
+"""HTTP Client for Buildfunctions API."""
+
+from __future__ import annotations
+
+from typing import Any
+from urllib.parse import urlencode, urljoin
+
+import httpx
+
+from buildfunctions.errors import AuthenticationError, BuildfunctionsError, error_from_response
+
+
+def create_http_client(base_url: str, api_token: str, timeout: float = 600.0) -> dict[str, Any]:
+    """Create an HTTP client for the Buildfunctions API.
+
+    Returns a dict with request/get/post/put/delete/set_token functions.
+    """
+    if not api_token:
+        raise AuthenticationError("API token is required")
+
+    resolved_base_url = base_url.rstrip("/")
+    state = {"token": api_token}
+
+    def _build_url(path: str, params: dict[str, str | int] | None = None) -> str:
+        url = f"{resolved_base_url}{path}"
+        if params:
+            query = urlencode({k: str(v) for k, v in params.items()})
+            url = f"{url}?{query}"
+        return url
+
+    async def _parse_response(response: httpx.Response) -> Any:
+        content_type = response.headers.get("content-type", "")
+        if "application/json" in content_type:
+            return response.json()
+        text = response.text
+        return {"message": text}
+
+    async def request(
+        method: str,
+        path: str,
+        body: dict[str, Any] | None = None,
+        params: dict[str, str | int] | None = None,
+    ) -> Any:
+        url = _build_url(path, params)
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {state['token']}",
+        }
+
+        try:
+            async with httpx.AsyncClient(timeout=httpx.Timeout(timeout)) as client:
+                response = await client.request(
+                    method=method,
+                    url=url,
+                    headers=headers,
+                    json=body,
+                )
+
+            data = await _parse_response(response)
+
+            if not response.is_success:
+                raise error_from_response(response.status_code, data if isinstance(data, dict) else {})
+
+            return data
+
+        except BuildfunctionsError:
+            raise
+        except httpx.TimeoutException:
+            raise BuildfunctionsError("Request timed out", "NETWORK_ERROR")
+        except httpx.ConnectError:
+            raise BuildfunctionsError("Unable to connect to server", "NETWORK_ERROR")
+        except Exception:
+            raise BuildfunctionsError("Request failed", "UNKNOWN_ERROR")
+
+    async def get(path: str, params: dict[str, str | int] | None = None) -> Any:
+        return await request("GET", path, params=params)
+
+    async def post(path: str, body: dict[str, Any] | None = None) -> Any:
+        return await request("POST", path, body=body)
+
+    async def put(path: str, body: dict[str, Any] | None = None) -> Any:
+        return await request("PUT", path, body=body)
+
+    async def delete(path: str, body: dict[str, Any] | None = None) -> Any:
+        return await request("DELETE", path, body=body)
+
+    def set_token(token: str) -> None:
+        state["token"] = token
+
+    return {
+        "request": request,
+        "get": get,
+        "post": post,
+        "put": put,
+        "delete": delete,
+        "set_token": set_token,
+    }

buildfunctions/memory.py

@@ -0,0 +1,28 @@
+"""Memory string parsing utility."""
+
+from __future__ import annotations
+
+import re
+
+
+def parse_memory(memory: str | int) -> int:
+    """Parse memory string to megabytes.
+
+    Accepts: "2GB", "1024MB", or raw int (treated as MB).
+    Returns value in MB.
+    """
+    if isinstance(memory, int):
+        return memory
+
+    text = memory.strip().upper()
+    match = re.match(r"^(\d+)\s*(GB|MB)$", text)
+
+    if not match:
+        raise ValueError(f'Invalid memory format: "{memory}". Use "2GB" or "1024MB".')
+
+    value = int(match.group(1))
+    unit = match.group(2)
+
+    if unit == "GB":
+        return value * 1024
+    return value  # MB

buildfunctions/resolve_code.py

@@ -0,0 +1,109 @@
+"""Resolve code parameter - supports both inline code and file paths.
+
+Relative paths (./foo.py, ../bar.py) are resolved relative to the caller's
+file location, not the current working directory.
+"""
+
+from __future__ import annotations
+
+import inspect
+from pathlib import Path
+
+from buildfunctions.errors import ValidationError
+
+# SDK directory - used to skip SDK frames when finding caller
+_SDK_DIR = Path(__file__).parent.resolve()
+
+CODE_EXTENSIONS = frozenset({
+    ".js", ".mjs", ".cjs", ".ts", ".tsx", ".jsx",  # JavaScript & TypeScript
+    ".py", ".pyw", ".pyi",                          # Python
+})
+
+
+def get_caller_file() -> Path | None:
+    """Get the file path of the caller (the file that called the SDK).
+
+    Used to resolve relative paths against the caller's location.
+    Skips frames that are inside the SDK itself.
+    """
+    for frame_info in inspect.stack():
+        frame_path = Path(frame_info.filename).resolve()
+
+        # Skip frames inside the SDK directory
+        try:
+            frame_path.relative_to(_SDK_DIR)
+            continue  # Frame is inside SDK, skip it
+        except ValueError:
+            pass  # Frame is outside SDK
+
+        # Skip frames that don't have a real file
+        if not frame_path.exists():
+            continue
+
+        return frame_path
+
+    return None
+
+
+def _looks_like_file_path(value: str) -> bool:
+    """Check if a string looks like a file path."""
+    if value.startswith(("/", "./", "../", "~")):
+        return True
+    # Windows drive letter
+    if len(value) >= 3 and value[1] == ":" and value[2] in ("/", "\\"):
+        return True
+    # Ends with known code file extension
+    dot_index = value.rfind(".")
+    if dot_index > 0:
+        ext = value[dot_index:].lower()
+        if ext in CODE_EXTENSIONS:
+            return True
+    return False
+
+
+async def resolve_code(code: str, base_path: Path | None = None) -> str:
+    """Resolve code string - reads from file if it's a path, returns as-is if inline.
+
+    Args:
+        code: Either inline code or a file path
+        base_path: Base directory for resolving relative paths (e.g., caller's directory).
+                   If not provided, automatically detects caller's file location.
+
+    Detection heuristic:
+    1. If the string contains a newline, treat as inline code.
+    2. If the resolved path exists on disk, read and return the file contents.
+    3. If it looks like a path but does not exist, raise ValidationError.
+    4. Otherwise treat as single-line inline code.
+    """
+    if "\n" in code:
+        return code
+
+    # Expand ~ to home directory
+    path_to_check = Path(code).expanduser()
+
+    # Resolve the path:
+    # - Absolute paths stay absolute
+    # - Relative paths resolve against base_path or caller's directory
+    if path_to_check.is_absolute():
+        resolved = path_to_check.resolve()
+    elif base_path:
+        resolved = (base_path / path_to_check).resolve()
+    else:
+        # Auto-detect caller's directory for relative paths
+        caller_file = get_caller_file()
+        if caller_file:
+            resolved = (caller_file.parent / path_to_check).resolve()
+        else:
+            resolved = path_to_check.resolve()
+
+    if resolved.exists() and resolved.is_file():
+        return resolved.read_text(encoding="utf-8")
+
+    if _looks_like_file_path(code):
+        raise ValidationError(
+            f'Code file not found: "{code}" (resolved to "{resolved}"). '
+            f"If this is meant to be inline code, ensure it is a valid code string."
+        )
+
+    # Single-line inline code
+    return code

buildfunctions/types.py

@@ -0,0 +1,227 @@
+"""Buildfunctions SDK Type Definitions."""
+
+from __future__ import annotations
+
+from typing import Any, Awaitable, Callable, Literal, TypedDict
+
+
+# Scalar types
+Language = Literal["javascript", "typescript", "python", "go", "shell"]
+Runtime = Literal["node", "deno", "python", "go", "shell"]
+GPUType = Literal["T4"]
+Framework = Literal["pytorch"]
+Memory = Literal["128Mi", "256Mi", "512Mi", "1Gi", "2Gi", "4Gi", "8Gi", "16Gi", "32Gi", "64Gi"]
+ErrorCode = Literal[
+    "UNAUTHORIZED",
+    "NOT_FOUND",
+    "INVALID_REQUEST",
+    "MAX_CAPACITY",
+    "SIZE_LIMIT_EXCEEDED",
+    "VALIDATION_ERROR",
+    "NETWORK_ERROR",
+    "UNKNOWN_ERROR",
+]
+
+
+# Client configuration
+class BuildfunctionsConfig(TypedDict, total=False):
+    api_token: str
+    base_url: str
+    gpu_build_url: str
+
+
+class _BuildfunctionsConfigRequired(TypedDict):
+    api_token: str
+
+
+# Authenticated user
+class AuthenticatedUser(TypedDict, total=False):
+    id: str
+    username: str | None
+    email: str | None
+    compute_tier: str | None
+
+
+# Auth response
+class AuthResponse(TypedDict):
+    authenticated: bool
+    user: AuthenticatedUser
+    sessionToken: str
+    expiresAt: str
+    authenticatedAt: str
+
+
+# Function configuration
+class FunctionConfig(TypedDict, total=False):
+    memory: str | int
+    timeout: int
+    cpu_cores: int
+
+
+# CPU function options
+class CPUFunctionOptions(TypedDict, total=False):
+    name: str
+    language: Language
+    runtime: Runtime
+    code: str  # Inline code string or path to file (absolute, relative, or ~/path)
+    config: FunctionConfig
+    env_variables: dict[str, str]
+    dependencies: str
+    cron_schedule: str
+
+
+# GPU function options (extends CPU)
+class GPUFunctionOptions(TypedDict, total=False):
+    name: str
+    language: Language
+    runtime: Runtime
+    code: str  # Inline code string or path to file (absolute, relative, or ~/path)
+    config: FunctionConfig
+    env_variables: dict[str, str]
+    dependencies: str
+    cron_schedule: str
+    gpu: GPUType
+    cpu_cores: int  # vCPUs for the GPU function VM (hotplugged at runtime, default 10, max 50)
+    framework: Framework
+    model_path: str
+    model_name: str
+
+
+# Create function options (for SDK deploy via client)
+class CreateFunctionOptions(TypedDict, total=False):
+    name: str
+    code: str  # Inline code string or path to file (absolute, relative, or ~/path)
+    language: Language
+    runtime: Runtime
+    memory: str | int
+    timeout: int
+    env_variables: list[dict[str, str]]
+    requirements: str | list[str]
+    cron_schedule: str
+    processor_type: Literal["CPU", "GPU"]
+    framework: Framework
+    gpu: GPUType
+    model_name: str
+    model_path: str
+
+
+# Deployed function
+class DeployedFunction(TypedDict, total=False):
+    id: str
+    name: str
+    subdomain: str
+    endpoint: str
+    lambdaUrl: str
+    language: str
+    runtime: str
+    lambdaMemoryAllocated: int
+    timeoutSeconds: int
+    cpuCores: str
+    isGPUF: bool
+    framework: str
+    createdAt: str
+    updatedAt: str
+    delete: Callable[[], Awaitable[None]]
+
+
+# Sandbox configuration
+class CPUSandboxConfig(TypedDict, total=False):
+    name: str
+    language: Language
+    runtime: Runtime
+    code: str  # Inline code string or path to file (absolute, relative, or ~/path)
+    memory: str | int
+    timeout: int
+    env_variables: list[dict[str, str]]
+    requirements: str | list[str]
+
+
+class GPUSandboxConfig(TypedDict, total=False):
+    name: str
+    language: Language
+    runtime: Runtime
+    code: str  # Inline code string or path to file (absolute, relative, or ~/path)
+    memory: str | int
+    timeout: int
+    env_variables: list[dict[str, str]]
+    requirements: str | list[str]
+    gpu: GPUType
+    cpu_cores: int  # vCPUs for the GPU sandbox VM (hotplugged at runtime, default 10, max 50)
+    model: str | dict[str, str]
+
+
+# Run result
+class RunResult(TypedDict):
+    response: Any   # The response (parsed JSON object, or raw string if not JSON)
+    status: int     # HTTP status code
+
+
+# Upload options
+class UploadOptions(TypedDict, total=False):
+    local_path: str
+    file_path: str
+
+
+# Sandbox instances
+class SandboxInstance(TypedDict, total=False):
+    id: str
+    name: str
+    runtime: str
+    endpoint: str
+    run: Callable[..., Awaitable[RunResult]]
+    upload: Callable[[UploadOptions], Awaitable[None]]
+    delete: Callable[[], Awaitable[None]]
+
+
+class CPUSandboxInstance(TypedDict, total=False):
+    id: str
+    name: str
+    runtime: str
+    endpoint: str
+    type: Literal["cpu"]
+    run: Callable[..., Awaitable[RunResult]]
+    upload: Callable[[UploadOptions], Awaitable[None]]
+    delete: Callable[[], Awaitable[None]]
+
+
+class GPUSandboxInstance(TypedDict, total=False):
+    id: str
+    name: str
+    runtime: str
+    endpoint: str
+    type: Literal["gpu"]
+    gpu: GPUType
+    run: Callable[..., Awaitable[RunResult]]
+    upload: Callable[[UploadOptions], Awaitable[None]]
+    delete: Callable[[], Awaitable[None]]
+
+
+# Find options
+class FindUniqueWhere(TypedDict, total=False):
+    name: str
+    id: str
+
+
+class FindUniqueOptions(TypedDict):
+    where: FindUniqueWhere
+
+
+class ListOptions(TypedDict, total=False):
+    page: int
+
+
+# File metadata (for uploads)
+class FileMetadata(TypedDict):
+    name: str
+    size: int
+    type: str
+    webkit_relative_path: str
+    local_path: str
+
+
+# Presigned URL info
+class PresignedUrlInfo(TypedDict, total=False):
+    signedUrl: list[str]
+    uploadId: str | None
+    numberOfParts: int
+    s3FilePath: str

buildfunctions/uploader.py

@@ -0,0 +1,198 @@
+"""File upload utilities for GPU Sandbox."""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+from typing import Any
+
+import httpx
+
+from buildfunctions.types import FileMetadata, PresignedUrlInfo
+
+CHUNK_SIZE = 9 * 1024 * 1024  # 9MB
+MAX_PARALLEL_UPLOADS = 5
+
+
+async def upload_file(content: bytes, presigned_url: str) -> None:
+    """Upload a single file to a presigned URL."""
+    async with httpx.AsyncClient(timeout=httpx.Timeout(600.0)) as client:
+        response = await client.put(
+            presigned_url,
+            content=content,
+            headers={"Content-Type": "application/octet-stream"},
+        )
+    if not response.is_success:
+        raise RuntimeError(f"Failed to upload file: {response.reason_phrase}")
+
+
+async def upload_part(content: bytes, presigned_url: str, part_number: int) -> dict[str, Any]:
+    """Upload a single part of a multipart upload."""
+    async with httpx.AsyncClient(timeout=httpx.Timeout(600.0)) as client:
+        response = await client.put(
+            presigned_url,
+            content=content,
+            headers={"Content-Type": "application/octet-stream"},
+        )
+
+    if not response.is_success:
+        raise RuntimeError(f"Failed to upload part {part_number}: {response.reason_phrase}")
+
+    etag = response.headers.get("ETag")
+    if not etag:
+        raise RuntimeError(f"Failed to retrieve ETag for part {part_number}")
+
+    clean_etag = etag.strip('"')
+    return {"PartNumber": part_number, "ETag": clean_etag}
+
+
+async def upload_multipart_file(
+    content: bytes,
+    signed_urls: list[str],
+    upload_id: str,
+    number_of_parts: int,
+    bucket_name: str,
+    s3_file_path: str,
+    base_url: str,
+) -> None:
+    """Orchestrate a multipart upload with parallel chunk uploads."""
+    parts: list[dict[str, Any]] = []
+    semaphore = asyncio.Semaphore(MAX_PARALLEL_UPLOADS)
+
+    async def _upload_chunk(index: int) -> None:
+        async with semaphore:
+            part_number = index + 1
+            start = index * CHUNK_SIZE
+            end = min(start + CHUNK_SIZE, len(content))
+            chunk = content[start:end]
+            url = signed_urls[index]
+            if not url:
+                raise RuntimeError(f"Missing upload URL for part {part_number}")
+            part = await upload_part(chunk, url, part_number)
+            parts.append(part)
+
+    tasks = [_upload_chunk(i) for i in range(number_of_parts)]
+    await asyncio.gather(*tasks)
+
+    sorted_parts = sorted(parts, key=lambda p: p["PartNumber"])
+
+    async with httpx.AsyncClient(timeout=httpx.Timeout(60.0)) as client:
+        response = await client.post(
+            f"{base_url}/api/functions/gpu/transfer-and-mount/complete-multipart-upload",
+            json={
+                "bucketName": bucket_name,
+                "uploadId": upload_id,
+                "parts": sorted_parts,
+                "s3FilePath": s3_file_path,
+                "fileName": s3_file_path.split("/")[-1] if "/" in s3_file_path else s3_file_path,
+            },
+        )
+
+    if not response.is_success:
+        error_text = response.text
+        raise RuntimeError(f"Failed to complete upload: {response.reason_phrase} - {error_text}")
+
+
+def get_files_in_directory(dir_path: str) -> list[FileMetadata]:
+    """Recursively walk a directory and collect file metadata."""
+    root = Path(dir_path)
+    root_dir_name = root.name
+    files: list[FileMetadata] = []
+
+    for file_path in root.rglob("*"):
+        if file_path.is_file():
+            relative = file_path.relative_to(root)
+            files.append(
+                FileMetadata(
+                    name=file_path.name,
+                    size=file_path.stat().st_size,
+                    type="application/octet-stream",
+                    webkit_relative_path=f"{root_dir_name}/{relative}",
+                    local_path=str(file_path),
+                )
+            )
+
+    return files
+
+
+async def upload_model_files(
+    files: list[FileMetadata],
+    presigned_urls: dict[str, PresignedUrlInfo],
+    bucket_name: str,
+    base_url: str,
+) -> None:
+    """Upload all model files using presigned URLs."""
+    upload_tasks: list[asyncio.Task[None]] = []
+
+    for file in files:
+        url_info = presigned_urls.get(file["webkit_relative_path"])
+        if not url_info:
+            print(f"No upload URL found for {file['webkit_relative_path']}")
+            continue
+
+        content = Path(file["local_path"]).read_bytes()
+        signed_urls = url_info["signedUrl"]
+
+        if len(signed_urls) > 1 and url_info.get("uploadId"):
+            upload_tasks.append(
+                asyncio.ensure_future(
+                    upload_multipart_file(
+                        content,
+                        signed_urls,
+                        url_info["uploadId"],  # type: ignore[arg-type]
+                        url_info.get("numberOfParts", len(signed_urls)),
+                        bucket_name,
+                        url_info.get("s3FilePath", ""),
+                        base_url,
+                    )
+                )
+            )
+        elif len(signed_urls) == 1 and signed_urls[0]:
+            upload_tasks.append(asyncio.ensure_future(upload_file(content, signed_urls[0])))
+
+    if upload_tasks:
+        await asyncio.gather(*upload_tasks)
+
+
+async def transfer_files_to_efs(
+    files: list[FileMetadata],
+    sanitized_model_name: str,
+    base_url: str,
+    session_token: str,
+) -> None:
+    """Transfer files to EFS storage."""
+    async with httpx.AsyncClient(timeout=httpx.Timeout(300.0)) as client:
+        details_response = await client.post(
+            f"{base_url}/api/sdk/sandbox/gpu/get-transfer-details",
+            headers={
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {session_token}",
+            },
+            json={
+                "shouldVerifyContents": False,
+                "filesToTransfer": [f["webkit_relative_path"] for f in files],
+                "sanitizedModelName": sanitized_model_name,
+                "fileNamesWithinModelFolder": [f["name"] for f in files],
+            },
+        )
+
+    if not details_response.is_success:
+        error_data = details_response.json()
+        raise RuntimeError(error_data.get("error", "Failed to prepare file transfer"))
+
+    transfer_data = details_response.json()
+    transfer_details = transfer_data["transferDetails"]
+    storage_api_url = transfer_data["storageApiUrl"]
+    storage_api_path = transfer_data["storageApiPath"]
+
+    valid_details = [d for d in transfer_details if d.get("fileName")]
+
+    async with httpx.AsyncClient(timeout=httpx.Timeout(300.0)) as client:
+        for file_detail in valid_details:
+            response = await client.post(
+                f"{storage_api_url}{storage_api_path}",
+                json=file_detail,
+            )
+            if not response.is_success:
+                error_text = response.text
+                raise RuntimeError(f"Failed to transfer {file_detail['fileName']}: {error_text}")