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

buildfunctions/__init__.py

@@ -1 +1,139 @@
-from .api import Buildfunctions
+"""Buildfunctions SDK - Python SDK for the serverless platform for AI agents.
+
+Example:
+    import asyncio
+    from buildfunctions import Buildfunctions, CPUSandbox, GPUSandbox, GPUFunction
+
+    async def main():
+        # Initialize the client (authenticates with the API)
+        client = await Buildfunctions({
+            "apiToken": os.environ["BUILDFUNCTIONS_API_TOKEN"]
+        })
+
+        # Access authenticated user info (supports both dot and bracket notation)
+        print(client.user.username)
+        print(client.authenticatedAt)
+
+        # Create a CPU sandbox
+        sandbox = await CPUSandbox.create({
+            "name": "my-sandbox",
+            "language": "python",
+            "memory": "512MB",
+        })
+
+        # Run code
+        result = await sandbox.run()
+        print(result.response)
+
+        # Clean up
+        await sandbox.delete()
+
+    asyncio.run(main())
+"""
+
+# Client exports - match TypeScript SDK naming exactly
+from buildfunctions.client import (
+    Buildfunctions,
+    buildfunctions,
+    createClient,
+    create_client,
+    init,
+)
+
+# Function builders - match TypeScript SDK naming exactly
+from buildfunctions.cpu_function import CPUFunction, create_cpu_function
+from buildfunctions.gpu_function import GPUFunction, create_gpu_function
+
+# Sandbox factories - match TypeScript SDK naming exactly
+from buildfunctions.cpu_sandbox import CPUSandbox, create_cpu_sandbox
+from buildfunctions.gpu_sandbox import GPUSandbox, create_gpu_sandbox
+
+# Errors
+from buildfunctions.errors import (
+    AuthenticationError,
+    BuildfunctionsError,
+    CapacityError,
+    NotFoundError,
+    ValidationError,
+)
+
+# Types
+from buildfunctions.types import (
+    AuthenticatedUser,
+    AuthResponse,
+    BuildfunctionsConfig,
+    CPUFunctionOptions,
+    CPUSandboxConfig,
+    CPUSandboxInstance,
+    CreateFunctionOptions,
+    DeployedFunction,
+    ErrorCode,
+    FileMetadata,
+    FindUniqueOptions,
+    Framework,
+    FunctionConfig,
+    GPUFunctionOptions,
+    GPUSandboxConfig,
+    GPUSandboxInstance,
+    GPUType,
+    Language,
+    ListOptions,
+    Memory,
+    RunResult,
+    Runtime,
+    SandboxInstance,
+    UploadOptions,
+)
+
+__all__ = [
+    # Client (PascalCase - matches TypeScript)
+    "Buildfunctions",
+    "createClient",
+    "init",
+    # Client (snake_case aliases)
+    "buildfunctions",
+    "create_client",
+    # Function builders (PascalCase - matches TypeScript)
+    "CPUFunction",
+    "GPUFunction",
+    # Function builders (snake_case aliases)
+    "create_cpu_function",
+    "create_gpu_function",
+    # Sandbox factories (PascalCase - matches TypeScript)
+    "CPUSandbox",
+    "GPUSandbox",
+    # Sandbox factories (snake_case aliases)
+    "create_cpu_sandbox",
+    "create_gpu_sandbox",
+    # Errors
+    "BuildfunctionsError",
+    "AuthenticationError",
+    "NotFoundError",
+    "ValidationError",
+    "CapacityError",
+    # Types
+    "BuildfunctionsConfig",
+    "AuthenticatedUser",
+    "AuthResponse",
+    "Language",
+    "Runtime",
+    "GPUType",
+    "Framework",
+    "Memory",
+    "FunctionConfig",
+    "CPUFunctionOptions",
+    "GPUFunctionOptions",
+    "CreateFunctionOptions",
+    "DeployedFunction",
+    "CPUSandboxConfig",
+    "GPUSandboxConfig",
+    "RunResult",
+    "UploadOptions",
+    "SandboxInstance",
+    "CPUSandboxInstance",
+    "GPUSandboxInstance",
+    "FindUniqueOptions",
+    "ListOptions",
+    "ErrorCode",
+    "FileMetadata",
+]

buildfunctions/client.py

@@ -0,0 +1,282 @@
+"""Buildfunctions SDK Client."""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+from typing import Any
+
+from buildfunctions.cpu_function import set_api_token
+from buildfunctions.cpu_sandbox import set_cpu_sandbox_api_token
+from buildfunctions.dotdict import DotDict
+from buildfunctions.errors import NotFoundError
+from buildfunctions.framework import detect_framework
+from buildfunctions.gpu_function import GPUFunction, set_gpu_api_token
+from buildfunctions.gpu_sandbox import set_gpu_sandbox_api_token
+from buildfunctions.http_client import create_http_client
+from buildfunctions.memory import parse_memory
+from buildfunctions.resolve_code import get_caller_file, resolve_code
+from buildfunctions.types import (
+    AuthResponse,
+    BuildfunctionsConfig,
+    CreateFunctionOptions,
+    DeployedFunction,
+    FindUniqueOptions,
+    ListOptions,
+)
+
+DEFAULT_BASE_URL = "https://www.buildfunctions.com"
+DEFAULT_GPU_BUILD_URL = "https://prod-gpu-build.buildfunctions.link"
+
+
+def _format_requirements(requirements: str | list[str] | None) -> str:
+    if not requirements:
+        return ""
+    if isinstance(requirements, list):
+        return "\n".join(requirements)
+    return requirements
+
+
+def _get_default_runtime(language: str) -> str:
+    if language == "javascript":
+        raise ValueError('JavaScript requires explicit runtime: "nodejs" or "deno"')
+    return language
+
+
+def _get_file_extension(language: str) -> str:
+    match language:
+        case "javascript":
+            return ".js"
+        case "typescript":
+            return ".ts"
+        case "python":
+            return ".py"
+        case "go":
+            return ".go"
+        case "shell":
+            return ".sh"
+        case _:
+            return ".js"
+
+
+def _create_functions_manager(http: dict[str, Any]) -> DotDict:
+    """Create a functions manager with list/findUnique/get/create/delete methods."""
+
+    def _wrap_function(fn: dict[str, Any]) -> DotDict:
+        async def delete_fn() -> None:
+            await http["delete"]("/api/sdk/functions/build", {"siteId": fn["id"]})
+
+        return DotDict({**fn, "delete": delete_fn})
+
+    async def list_fn(options: ListOptions | None = None) -> list[DotDict]:
+        page = (options or {}).get("page", 1)
+        response = await http["get"]("/api/sdk/functions", {"page": page})
+        return [_wrap_function(fn) for fn in response["stringifiedQueryResults"]]
+
+    async def find_unique(options: FindUniqueOptions) -> DotDict | None:
+        where = options.get("where", options) if isinstance(options, dict) else options
+
+        if where.get("id"):
+            try:
+                fn = await http["get"]("/api/sdk/functions/build", {"siteId": where["id"]})
+                return _wrap_function(fn)
+            except NotFoundError:
+                return None
+
+        if where.get("name"):
+            functions = await list_fn()
+            for fn in functions:
+                if fn.get("name") == where["name"]:
+                    return fn
+            return None
+
+        return None
+
+    async def get(site_id: str) -> DotDict:
+        fn = await http["get"]("/api/sdk/functions/build", {"siteId": site_id})
+        return _wrap_function(fn)
+
+    async def create(options: CreateFunctionOptions) -> DotDict:
+        # Get the caller's file location to resolve relative paths correctly
+        caller_file = get_caller_file()
+        caller_dir = caller_file.parent if caller_file else None
+
+        # Resolve code (inline string or file path) relative to the caller's location
+        resolved_code = await resolve_code(options["code"], caller_dir)
+
+        file_ext = _get_file_extension(options["language"])
+        name = options["name"].lower()
+        is_gpu = options.get("processor_type") == "GPU" or bool(options.get("gpu"))
+        runtime = options.get("runtime") or _get_default_runtime(options["language"])
+
+        if is_gpu:
+            requirements = _format_requirements(options.get("requirements"))
+            env_variables_list = options.get("env_variables", [])
+            env_dict = {v["key"]: v["value"] for v in env_variables_list} if env_variables_list else {}
+
+            deployed = await GPUFunction.create({
+                "name": options["name"],
+                "code": resolved_code,
+                "language": options["language"],
+                "runtime": runtime,
+                "gpu": options.get("gpu", "T4"),
+                "vcpus": options.get("vcpus"),
+                "config": {
+                    "memory": parse_memory(options["memory"]) if options.get("memory") else 1024,
+                    "timeout": options.get("timeout", 60),
+                },
+                "dependencies": requirements,
+                "env_variables": env_dict if env_dict else {},
+                "cron_schedule": options.get("cron_schedule", ""),
+                "framework": options.get("framework") or detect_framework(requirements),
+                "model_name": options.get("model_name", ""),
+                "model_path": options.get("model_path", ""),
+            })
+
+            if not deployed:
+                raise RuntimeError("GPU Function deployment failed")
+            return DotDict(deployed) if not isinstance(deployed, DotDict) else deployed
+
+        # CPU build
+        body = {
+            "name": name,
+            "fileExt": file_ext,
+            "sourceWith": resolved_code,
+            "sourceWithout": resolved_code,
+            "language": options["language"],
+            "runtime": runtime,
+            "memoryAllocated": parse_memory(options["memory"]) if options.get("memory") else 128,
+            "timeout": options.get("timeout", 10),
+            "envVariables": json.dumps(options.get("env_variables", [])),
+            "requirements": _format_requirements(options.get("requirements")),
+            "cronExpression": options.get("cron_schedule", ""),
+            "processorType": "CPU",
+            "selectedFramework": options.get("framework") or detect_framework(
+                _format_requirements(options.get("requirements"))
+            ),
+            "subdomain": name,
+            "totalVariables": len(options.get("env_variables", [])),
+            "functionCount": 0,
+        }
+
+        response = await http["post"]("/api/sdk/functions/build", body)
+        now = datetime.now(timezone.utc).isoformat()
+
+        return _wrap_function({
+            "id": response["siteId"],
+            "name": name,
+            "subdomain": name,
+            "endpoint": response["endpoint"],
+            "lambdaUrl": response.get("sslCertificateEndpoint", ""),
+            "language": options["language"],
+            "runtime": runtime,
+            "lambdaMemoryAllocated": parse_memory(options["memory"]) if options.get("memory") else 128,
+            "timeoutSeconds": options.get("timeout", 10),
+            "isGPUF": False,
+            "framework": options.get("framework", ""),
+            "createdAt": now,
+            "updatedAt": now,
+        })
+
+    async def delete_fn(site_id: str) -> None:
+        await http["delete"]("/api/sdk/functions/build", {"siteId": site_id})
+
+    return DotDict({
+        "list": list_fn,
+        "findUnique": find_unique,
+        "find_unique": find_unique,
+        "get": get,
+        "create": create,
+        "delete": delete_fn,
+    })
+
+
+async def Buildfunctions(config: BuildfunctionsConfig | None = None) -> DotDict:
+    """Create a Buildfunctions SDK client.
+
+    Authenticates with the API and returns a client with:
+    - functions: Functions manager (list, findUnique, get, create, delete)
+    - user: Authenticated user info
+    - sessionExpiresAt: Session expiration timestamp
+    - authenticatedAt: Authentication timestamp
+    - getHttpClient: Returns the underlying HTTP client
+
+    Supports both dot notation and bracket notation:
+        client.user.username  OR  client["user"]["username"]
+    """
+    if config is None:
+        import os
+
+        from dotenv import load_dotenv
+
+        load_dotenv()
+        api_token = os.environ.get("BUILDFUNCTIONS_API_TOKEN", "")
+        config = BuildfunctionsConfig(api_token=api_token)
+
+    api_token = config.get("api_token") or config.get("apiToken", "")
+    if not api_token:
+        raise ValueError("API token is required")
+
+    base_url = config.get("base_url") or config.get("baseUrl", DEFAULT_BASE_URL)
+    gpu_build_url = config.get("gpu_build_url") or config.get("gpuBuildUrl", DEFAULT_GPU_BUILD_URL)
+
+    # Don't wrap http in DotDict - it has methods like 'get' that conflict with dict builtins
+    http = create_http_client(base_url=base_url, api_token=api_token)
+
+    auth_response: AuthResponse = await http["post"]("/api/sdk/auth")
+
+    if not auth_response.get("authenticated"):
+        raise RuntimeError("Authentication failed")
+
+    http["set_token"](auth_response["sessionToken"])
+
+    user_id = auth_response["user"].get("id", "")
+    username = auth_response["user"].get("username") or None
+    compute_tier = auth_response["user"].get("compute_tier") or auth_response["user"].get("computeTier") or None
+
+    set_cpu_sandbox_api_token(auth_response["sessionToken"], base_url)
+    set_gpu_sandbox_api_token(auth_response["sessionToken"], gpu_build_url, user_id, username, compute_tier, base_url)
+    set_gpu_api_token(auth_response["sessionToken"], gpu_build_url, base_url, user_id, username, compute_tier)
+    set_api_token(auth_response["sessionToken"], base_url)
+
+    functions = _create_functions_manager(http)
+
+    return DotDict({
+        "functions": functions,
+        "user": DotDict(auth_response["user"]),
+        # Support both naming conventions
+        "sessionExpiresAt": auth_response.get("expiresAt"),
+        "session_expires_at": auth_response.get("expiresAt"),
+        "authenticatedAt": auth_response.get("authenticatedAt"),
+        "authenticated_at": auth_response.get("authenticatedAt"),
+        "getHttpClient": lambda: http,
+        "get_http_client": lambda: http,
+    })
+
+
+async def createClient(config: BuildfunctionsConfig | None = None) -> dict[str, Any] | None:
+    """Create a Buildfunctions client, returning None on failure."""
+    try:
+        return await Buildfunctions(config)
+    except Exception:
+        return None
+
+
+# Aliases for snake_case compatibility
+buildfunctions = Buildfunctions
+create_client = createClient
+
+
+def init(
+    api_token: str,
+    base_url: str | None = None,
+    gpu_build_url: str | None = None,
+    user_id: str | None = None,
+    username: str | None = None,
+    compute_tier: str | None = None,
+) -> None:
+    """Global initialization - sets tokens across all modules."""
+    set_api_token(api_token, base_url)
+    set_gpu_api_token(api_token, gpu_build_url, base_url, user_id, username, compute_tier)
+    set_cpu_sandbox_api_token(api_token, base_url)
+    set_gpu_sandbox_api_token(api_token, gpu_build_url, user_id, username, compute_tier, base_url)

buildfunctions/cpu_function.py

@@ -0,0 +1,167 @@
+"""CPU Function - Deploy serverless functions to Buildfunctions."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+import httpx
+
+from buildfunctions.dotdict import DotDict
+from buildfunctions.errors import ValidationError
+from buildfunctions.memory import parse_memory
+from buildfunctions.resolve_code import resolve_code
+from buildfunctions.types import CPUFunctionOptions, DeployedFunction
+
+DEFAULT_BASE_URL = "https://www.buildfunctions.com"
+
+# Module-level state
+_global_api_token: str | None = None
+_global_base_url: str | None = None
+
+
+def set_api_token(api_token: str, base_url: str | None = None) -> None:
+    """Set the API token for function deployment."""
+    global _global_api_token, _global_base_url
+    _global_api_token = api_token
+    _global_base_url = base_url
+
+
+def _get_file_extension(language: str) -> str:
+    extensions: dict[str, str] = {
+        "javascript": ".js",
+        "typescript": ".ts",
+        "python": ".py",
+        "go": ".go",
+        "shell": ".sh",
+    }
+    return extensions.get(language, ".js")
+
+
+def _get_default_runtime(language: str) -> str:
+    if language == "javascript":
+        raise ValidationError('JavaScript requires explicit runtime: "nodejs" or "deno"')
+    return language
+
+
+def _format_requirements(requirements: str | list[str] | None) -> str:
+    if not requirements:
+        return ""
+    if isinstance(requirements, list):
+        return "\n".join(requirements)
+    return requirements
+
+
+def _validate_options(options: CPUFunctionOptions) -> None:
+    name = options.get("name")
+    if not name or not isinstance(name, str):
+        raise ValidationError("Function name is required")
+
+    import re
+
+    if not re.match(r"^[a-z0-9-]+$", name.lower()):
+        raise ValidationError("Function name can only contain lowercase letters, numbers, and hyphens")
+
+    code = options.get("code")
+    if not code or not isinstance(code, str):
+        raise ValidationError("Function code is required")
+
+    if not options.get("language"):
+        raise ValidationError("Language is required")
+
+
+def _build_request_body(options: CPUFunctionOptions) -> dict[str, Any]:
+    name = options["name"]
+    language = options["language"]
+    code = options["code"]
+    config = options.get("config", {})
+    env_variables = options.get("env_variables", {})
+    dependencies = options.get("dependencies")
+    cron_schedule = options.get("cron_schedule")
+
+    runtime = options.get("runtime") or _get_default_runtime(language)
+    file_ext = _get_file_extension(language)
+
+    env_vars_list = [{"key": k, "value": v} for k, v in env_variables.items()] if env_variables else []
+
+    return {
+        "name": name.lower(),
+        "language": language,
+        "runtime": runtime,
+        "sourceWith": code,
+        "fileExt": file_ext,
+        "processorType": "CPU only",
+        "memoryAllocated": parse_memory(config.get("memory", 1024)) if config.get("memory") else 1024,
+        "timeout": config.get("timeout", 10) if config else 10,
+        "envVariables": json.dumps(env_vars_list),
+        "requirements": _format_requirements(dependencies),
+        "cronExpression": cron_schedule or "",
+        "totalVariables": len(env_variables) if env_variables else 0,
+    }
+
+
+async def _create_cpu_function(options: CPUFunctionOptions) -> DeployedFunction | None:
+    """Internal function to create and deploy a CPU function."""
+    if not _global_api_token:
+        raise ValidationError("API key not set. Initialize Buildfunctions client first.")
+
+    api_token = _global_api_token
+    base_url = _global_base_url or DEFAULT_BASE_URL
+
+    resolved_code = await resolve_code(options["code"])
+    resolved_options = {**options, "code": resolved_code}
+    _validate_options(resolved_options)
+    body = _build_request_body(resolved_options)
+
+    async with httpx.AsyncClient(timeout=httpx.Timeout(600.0)) as client:
+        response = await client.post(
+            f"{base_url}/api/sdk/functions/build",
+            headers={
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {api_token}",
+            },
+            json=body,
+        )
+
+    if not response.is_success:
+        return None
+
+    data = response.json()
+    name = options["name"].lower()
+    runtime = options.get("runtime") or _get_default_runtime(options["language"])
+
+    async def delete_fn() -> None:
+        async with httpx.AsyncClient(timeout=httpx.Timeout(30.0)) as c:
+            await c.request(
+                "DELETE",
+                f"{base_url}/api/sdk/functions/build",
+                headers={
+                    "Content-Type": "application/json",
+                    "Authorization": f"Bearer {api_token}",
+                },
+                json={"siteId": data.get("siteId")},
+            )
+
+    return DotDict({
+        "id": data.get("siteId", ""),
+        "name": name,
+        "subdomain": name,
+        "endpoint": data.get("endpoint", ""),
+        "lambdaUrl": data.get("sslCertificateEndpoint", ""),
+        "language": options["language"],
+        "runtime": runtime,
+        "isGPUF": False,
+        "delete": delete_fn,
+    })
+
+
+class CPUFunction:
+    """CPU Function factory - matches TypeScript SDK pattern."""
+
+    @staticmethod
+    async def create(options: CPUFunctionOptions) -> DeployedFunction | None:
+        """Create and deploy a new CPU function."""
+        return await _create_cpu_function(options)
+
+
+create_cpu_function = _create_cpu_function