zerodb-supabase 0.1.0__py3-none-any.whl

zerodb_supabase/__init__.py

@@ -0,0 +1,29 @@
+"""
+zerodb-supabase -- Drop-in Supabase Python client replacement backed by ZeroDB.
+
+Change one import, keep the same API:
+
+    # Before (supabase-py)
+    from supabase import create_client
+
+    # After (zerodb-supabase)
+    from zerodb_supabase import create_client
+
+Free cloud database. No Supabase account needed.
+Auto-provisions on first use.
+"""
+
+from zerodb_supabase.client import Client, create_client  # noqa: F401
+from zerodb_supabase.query import QueryBuilder  # noqa: F401
+from zerodb_supabase.storage import StorageClient, StorageBucket  # noqa: F401
+from zerodb_supabase.functions import FunctionsClient  # noqa: F401
+
+__version__ = "0.1.0"
+__all__ = [
+    "Client",
+    "create_client",
+    "QueryBuilder",
+    "StorageClient",
+    "StorageBucket",
+    "FunctionsClient",
+]

zerodb_supabase/client.py

@@ -0,0 +1,113 @@
+"""
+Client -- Supabase-compatible client backed by ZeroDB.
+
+Drop-in replacement: same interface as supabase.Client.
+
+    from zerodb_supabase import create_client
+
+    client = create_client()
+    data = client.table('users').select('*').execute()
+"""
+
+import requests
+
+from zerodb_supabase.provision import resolve_credentials
+from zerodb_supabase.query import QueryBuilder
+from zerodb_supabase.storage import StorageClient
+from zerodb_supabase.functions import FunctionsClient
+
+
+def create_client(supabase_url=None, supabase_key=None, **kwargs):
+    """Create a Supabase-compatible client backed by ZeroDB.
+
+    Supabase-compatible signature. If no URL/key provided, auto-provisions
+    a free ZeroDB project.
+
+    Args:
+        supabase_url: Ignored (kept for Supabase API compatibility).
+            Use ZERODB_BASE_URL env var to override the ZeroDB endpoint.
+        supabase_key: Used as ZeroDB API key if provided.
+        **kwargs: Extra options (api_key, project_id, base_url).
+
+    Returns:
+        Client instance.
+    """
+    api_key = kwargs.get("api_key") or supabase_key
+    project_id = kwargs.get("project_id")
+    base_url = kwargs.get("base_url")
+    return Client(api_key=api_key, project_id=project_id, base_url=base_url)
+
+
+class Client:
+    """Supabase-compatible client backed by ZeroDB.
+
+    Provides:
+      - table(name) -> QueryBuilder for CRUD operations
+      - storage -> StorageClient for file operations
+      - functions -> FunctionsClient for serverless functions
+    """
+
+    def __init__(self, api_key=None, project_id=None, base_url=None):
+        self._api_key, self._project_id, self._base_url = resolve_credentials(
+            api_key=api_key,
+            project_id=project_id,
+        )
+        if base_url:
+            self._base_url = base_url
+
+        self._session = requests.Session()
+        self._session.headers.update({
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self._api_key}",
+            "X-Project-ID": self._project_id,
+        })
+
+        self._tables_url = f"{self._base_url}/api/v1/public/tables"
+        self._files_url = f"{self._base_url}/api/v1/public/files"
+        self._hooks_url = f"{self._base_url}/api/v1/public/hooks"
+
+        self._storage = None
+        self._functions = None
+
+    @property
+    def storage(self):
+        """Access storage operations (S3-compatible via ZeroDB files API)."""
+        if self._storage is None:
+            self._storage = StorageClient(self._session, self._files_url)
+        return self._storage
+
+    @property
+    def functions(self):
+        """Access serverless functions (ZeroDB hooks API)."""
+        if self._functions is None:
+            self._functions = FunctionsClient(self._session, self._hooks_url)
+        return self._functions
+
+    def table(self, table_name):
+        """Start a query on a table. Returns a QueryBuilder.
+
+        Args:
+            table_name: Name of the table to query.
+
+        Returns:
+            QueryBuilder instance for chaining operations.
+        """
+        return QueryBuilder(self._session, self._tables_url, table_name)
+
+    def from_(self, table_name):
+        """Alias for table(). Matches supabase-py's from_() method."""
+        return self.table(table_name)
+
+    def rpc(self, function_name, params=None):
+        """Call a stored procedure / RPC function.
+
+        Maps to ZeroDB hooks API.
+
+        Args:
+            function_name: Name of the function.
+            params: Dict of parameters to pass.
+
+        Returns:
+            APIResponse with the result.
+        """
+        return self.functions.invoke(function_name, params or {})

zerodb_supabase/functions.py

@@ -0,0 +1,121 @@
+"""
+FunctionsClient -- Supabase Edge Functions-compatible interface backed by ZeroDB hooks API.
+
+    result = client.functions.invoke('process-upload', {'file_id': '123'})
+"""
+
+
+class FunctionResponse:
+    """Response wrapper for function invocations."""
+
+    def __init__(self, data=None, status_code=200):
+        self.data = data
+        self.status_code = status_code
+
+    def __repr__(self):
+        return f"FunctionResponse(data={self.data!r})"
+
+
+class FunctionsClient:
+    """Supabase FunctionsClient-compatible interface backed by ZeroDB hooks API.
+
+    Maps Supabase Edge Functions to ZeroDB's hooks/functions system.
+    """
+
+    def __init__(self, session, hooks_url):
+        self._session = session
+        self._hooks_url = hooks_url
+
+    def invoke(self, function_name, invoke_options=None):
+        """Invoke a serverless function.
+
+        Args:
+            function_name: Name of the function to invoke.
+            invoke_options: Dict with body, headers, method, etc.
+                Compatible with Supabase invoke options.
+
+        Returns:
+            FunctionResponse with the result.
+        """
+        options = invoke_options or {}
+
+        # Supabase supports body as dict or the options dict itself
+        body = options.get("body", options) if isinstance(options, dict) else options
+
+        # Build request
+        headers = {}
+        if isinstance(options, dict) and "headers" in options:
+            headers = options["headers"]
+
+        method = "POST"
+        if isinstance(options, dict) and "method" in options:
+            method = options["method"].upper()
+
+        resp = self._session.request(
+            method,
+            f"{self._hooks_url}/invoke/{function_name}",
+            json=body if method in ("POST", "PUT", "PATCH") else None,
+            params=body if method == "GET" else None,
+            headers=headers,
+        )
+        resp.raise_for_status()
+
+        try:
+            data = resp.json()
+        except ValueError:
+            data = resp.text
+
+        return FunctionResponse(data=data, status_code=resp.status_code)
+
+    def list(self):
+        """List all available functions.
+
+        Returns:
+            list of function info dicts.
+        """
+        resp = self._session.get(f"{self._hooks_url}/list")
+        resp.raise_for_status()
+        return resp.json()
+
+    def get(self, function_name):
+        """Get info about a specific function.
+
+        Args:
+            function_name: Function name.
+
+        Returns:
+            dict with function info.
+        """
+        resp = self._session.get(f"{self._hooks_url}/{function_name}")
+        resp.raise_for_status()
+        return resp.json()
+
+    def create(self, function_name, body=None):
+        """Create/deploy a new function.
+
+        Args:
+            function_name: Function name.
+            body: Dict with function code/config.
+
+        Returns:
+            dict with created function info.
+        """
+        payload = {"name": function_name}
+        if body:
+            payload.update(body)
+        resp = self._session.post(f"{self._hooks_url}/create", json=payload)
+        resp.raise_for_status()
+        return resp.json()
+
+    def delete(self, function_name):
+        """Delete a function.
+
+        Args:
+            function_name: Function name.
+
+        Returns:
+            dict with result.
+        """
+        resp = self._session.delete(f"{self._hooks_url}/{function_name}")
+        resp.raise_for_status()
+        return resp.json()

zerodb_supabase/provision.py

@@ -0,0 +1,102 @@
+"""
+Auto-provisioning for ZeroDB.
+
+Resolves credentials in order:
+1. Explicit constructor args
+2. Environment variables (ZERODB_API_KEY, ZERODB_PROJECT_ID)
+3. Config file (~/.zerodb/config.json)
+4. Auto-provision via Instant DB endpoint (free, no signup)
+"""
+
+import json
+import os
+from pathlib import Path
+
+import requests
+
+ZERODB_API_BASE = "https://api.ainative.studio"
+INSTANT_DB_ENDPOINT = f"{ZERODB_API_BASE}/api/v1/public/instant-db"
+CONFIG_DIR = Path.home() / ".zerodb"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+
+
+def _load_config_file():
+    """Load credentials from ~/.zerodb/config.json if it exists."""
+    if CONFIG_FILE.exists():
+        try:
+            data = json.loads(CONFIG_FILE.read_text())
+            api_key = data.get("api_key")
+            project_id = data.get("project_id")
+            if api_key and project_id:
+                return api_key, project_id
+        except (json.JSONDecodeError, OSError):
+            pass
+    return None, None
+
+
+def _save_config_file(api_key, project_id, claim_url=None):
+    """Save credentials to ~/.zerodb/config.json."""
+    try:
+        CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+        data = {"api_key": api_key, "project_id": project_id}
+        if claim_url:
+            data["claim_url"] = claim_url
+        CONFIG_FILE.write_text(json.dumps(data, indent=2))
+    except OSError:
+        pass  # Best-effort -- don't crash if home dir is read-only
+
+
+def _auto_provision():
+    """Create an instant ZeroDB project (free, no signup required)."""
+    resp = requests.post(
+        INSTANT_DB_ENDPOINT,
+        json={"source": "zerodb-supabase"},
+        headers={"Content-Type": "application/json"},
+        timeout=30,
+    )
+    resp.raise_for_status()
+    data = resp.json()
+
+    api_key = data["api_key"]
+    project_id = data["project_id"]
+    claim_url = data.get("claim_url")
+
+    # Persist for future runs
+    _save_config_file(api_key, project_id, claim_url)
+
+    if claim_url:
+        print(
+            f"\n  zerodb-supabase: Auto-provisioned free project."
+            f"\n  Claim it at: {claim_url}"
+            f"\n  Project: {project_id}"
+            f"\n  This message only appears once.\n"
+        )
+
+    return api_key, project_id
+
+
+def resolve_credentials(api_key=None, project_id=None):
+    """Resolve ZeroDB credentials from args, env, config, or auto-provision.
+
+    Returns (api_key, project_id, base_url).
+    """
+    base_url = os.environ.get("ZERODB_BASE_URL", ZERODB_API_BASE)
+
+    # 1. Explicit args
+    if api_key and project_id:
+        return api_key, project_id, base_url
+
+    # 2. Environment variables
+    env_key = os.environ.get("ZERODB_API_KEY")
+    env_project = os.environ.get("ZERODB_PROJECT_ID")
+    if env_key and env_project:
+        return env_key, env_project, base_url
+
+    # 3. Config file
+    file_key, file_project = _load_config_file()
+    if file_key and file_project:
+        return file_key, file_project, base_url
+
+    # 4. Auto-provision
+    auto_key, auto_project = _auto_provision()
+    return auto_key, auto_project, base_url

zerodb_supabase/query.py

@@ -0,0 +1,407 @@
+"""
+QueryBuilder -- Supabase-compatible query builder for ZeroDB tables.
+
+Supports the Supabase chaining pattern:
+
+    client.table('users').select('*').eq('active', True).limit(10).execute()
+"""
+
+
+class APIResponse:
+    """Response wrapper matching Supabase APIResponse."""
+
+    def __init__(self, data, count=None, status_code=200):
+        self.data = data
+        self.count = count
+        self.status_code = status_code
+
+    def __repr__(self):
+        return f"APIResponse(data={self.data!r}, count={self.count})"
+
+
+class QueryBuilder:
+    """Chainable query builder that maps Supabase query API to ZeroDB.
+
+    Usage:
+        qb = QueryBuilder(session, base_url, 'users')
+        result = qb.select('*').eq('active', True).execute()
+    """
+
+    def __init__(self, session, tables_url, table_name):
+        self._session = session
+        self._tables_url = tables_url
+        self._table = table_name
+        self._operation = None  # 'select', 'insert', 'update', 'upsert', 'delete'
+        self._columns = "*"
+        self._filters = []
+        self._order_col = None
+        self._order_asc = True
+        self._limit_val = None
+        self._offset_val = None
+        self._data = None
+        self._count_mode = None
+        self._single = False
+
+    # ------------------------------------------------------------------
+    # Operations
+    # ------------------------------------------------------------------
+
+    def select(self, columns="*", count=None):
+        """Select columns from the table.
+
+        Args:
+            columns: Column names (comma-separated string or '*').
+            count: Count mode ('exact', 'planned', 'estimated') or None.
+
+        Returns:
+            self for chaining.
+        """
+        self._operation = "select"
+        self._columns = columns
+        self._count_mode = count
+        return self
+
+    def insert(self, data, count=None):
+        """Insert row(s) into the table.
+
+        Args:
+            data: Dict (single row) or list of dicts (multiple rows).
+            count: Count mode or None.
+
+        Returns:
+            self for chaining.
+        """
+        self._operation = "insert"
+        self._data = data if isinstance(data, list) else [data]
+        self._count_mode = count
+        return self
+
+    def update(self, data, count=None):
+        """Update rows matching filters.
+
+        Args:
+            data: Dict of columns to update.
+            count: Count mode or None.
+
+        Returns:
+            self for chaining.
+        """
+        self._operation = "update"
+        self._data = data
+        self._count_mode = count
+        return self
+
+    def upsert(self, data, count=None):
+        """Insert or update row(s).
+
+        Args:
+            data: Dict or list of dicts.
+            count: Count mode or None.
+
+        Returns:
+            self for chaining.
+        """
+        self._operation = "upsert"
+        self._data = data if isinstance(data, list) else [data]
+        self._count_mode = count
+        return self
+
+    def delete(self, count=None):
+        """Delete rows matching filters.
+
+        Args:
+            count: Count mode or None.
+
+        Returns:
+            self for chaining.
+        """
+        self._operation = "delete"
+        self._count_mode = count
+        return self
+
+    # ------------------------------------------------------------------
+    # Filters (PostgREST-compatible)
+    # ------------------------------------------------------------------
+
+    def eq(self, column, value):
+        """Equal to."""
+        self._filters.append({"column": column, "op": "eq", "value": value})
+        return self
+
+    def neq(self, column, value):
+        """Not equal to."""
+        self._filters.append({"column": column, "op": "neq", "value": value})
+        return self
+
+    def gt(self, column, value):
+        """Greater than."""
+        self._filters.append({"column": column, "op": "gt", "value": value})
+        return self
+
+    def gte(self, column, value):
+        """Greater than or equal to."""
+        self._filters.append({"column": column, "op": "gte", "value": value})
+        return self
+
+    def lt(self, column, value):
+        """Less than."""
+        self._filters.append({"column": column, "op": "lt", "value": value})
+        return self
+
+    def lte(self, column, value):
+        """Less than or equal to."""
+        self._filters.append({"column": column, "op": "lte", "value": value})
+        return self
+
+    def like(self, column, pattern):
+        """LIKE pattern match."""
+        self._filters.append({"column": column, "op": "like", "value": pattern})
+        return self
+
+    def ilike(self, column, pattern):
+        """Case-insensitive LIKE pattern match."""
+        self._filters.append({"column": column, "op": "ilike", "value": pattern})
+        return self
+
+    def is_(self, column, value):
+        """IS check (for null/true/false)."""
+        self._filters.append({"column": column, "op": "is", "value": value})
+        return self
+
+    def in_(self, column, values):
+        """IN check (value in list)."""
+        self._filters.append({"column": column, "op": "in", "value": values})
+        return self
+
+    def contains(self, column, value):
+        """Contains (for arrays/JSON)."""
+        self._filters.append({"column": column, "op": "cs", "value": value})
+        return self
+
+    def contained_by(self, column, value):
+        """Contained by (for arrays/JSON)."""
+        self._filters.append({"column": column, "op": "cd", "value": value})
+        return self
+
+    def not_(self, column, op, value):
+        """Negate a filter."""
+        self._filters.append({"column": column, "op": f"not.{op}", "value": value})
+        return self
+
+    def or_(self, *filters):
+        """OR filter (comma-separated PostgREST conditions)."""
+        self._filters.append({"op": "or", "value": filters})
+        return self
+
+    def filter(self, column, op, value):
+        """Generic filter."""
+        self._filters.append({"column": column, "op": op, "value": value})
+        return self
+
+    # ------------------------------------------------------------------
+    # Modifiers
+    # ------------------------------------------------------------------
+
+    def order(self, column, desc=False):
+        """Order results by column.
+
+        Args:
+            column: Column name.
+            desc: If True, order descending.
+
+        Returns:
+            self for chaining.
+        """
+        self._order_col = column
+        self._order_asc = not desc
+        return self
+
+    def limit(self, count):
+        """Limit number of results.
+
+        Args:
+            count: Maximum number of rows.
+
+        Returns:
+            self for chaining.
+        """
+        self._limit_val = count
+        return self
+
+    def offset(self, count):
+        """Skip first N results (for pagination).
+
+        Args:
+            count: Number of rows to skip.
+
+        Returns:
+            self for chaining.
+        """
+        self._offset_val = count
+        return self
+
+    def range(self, start, end):
+        """Limit to a range of rows.
+
+        Args:
+            start: Start index.
+            end: End index (inclusive).
+
+        Returns:
+            self for chaining.
+        """
+        self._offset_val = start
+        self._limit_val = end - start + 1
+        return self
+
+    def single(self):
+        """Return a single row instead of a list.
+
+        Returns:
+            self for chaining.
+        """
+        self._single = True
+        self._limit_val = 1
+        return self
+
+    def maybe_single(self):
+        """Return a single row or None.
+
+        Returns:
+            self for chaining.
+        """
+        self._single = True
+        self._limit_val = 1
+        return self
+
+    # ------------------------------------------------------------------
+    # Execution
+    # ------------------------------------------------------------------
+
+    def _build_query_body(self):
+        """Build the request body for ZeroDB tables API."""
+        body = {"table": self._table}
+
+        if self._filters:
+            body["filters"] = self._filters
+
+        if self._columns != "*":
+            body["columns"] = [c.strip() for c in self._columns.split(",")]
+
+        if self._order_col:
+            body["order_by"] = {
+                "column": self._order_col,
+                "ascending": self._order_asc,
+            }
+
+        if self._limit_val is not None:
+            body["limit"] = self._limit_val
+
+        if self._offset_val is not None:
+            body["offset"] = self._offset_val
+
+        return body
+
+    def execute(self):
+        """Execute the query and return an APIResponse.
+
+        Returns:
+            APIResponse with data and optional count.
+        """
+        if self._operation == "select":
+            return self._execute_select()
+        elif self._operation == "insert":
+            return self._execute_insert()
+        elif self._operation == "update":
+            return self._execute_update()
+        elif self._operation == "upsert":
+            return self._execute_upsert()
+        elif self._operation == "delete":
+            return self._execute_delete()
+        else:
+            raise ValueError(
+                "No operation specified. Call select(), insert(), update(), "
+                "upsert(), or delete() before execute()."
+            )
+
+    def _execute_select(self):
+        """Execute a SELECT query via ZeroDB tables API."""
+        body = self._build_query_body()
+        body["operation"] = "query"
+
+        resp = self._session.post(f"{self._tables_url}/query", json=body)
+        resp.raise_for_status()
+        result = resp.json()
+
+        rows = result.get("rows", result.get("data", result))
+        if isinstance(rows, dict):
+            rows = rows.get("rows", [rows])
+
+        count = result.get("count") if self._count_mode else None
+
+        if self._single:
+            rows = rows[0] if rows else None
+
+        return APIResponse(data=rows, count=count, status_code=resp.status_code)
+
+    def _execute_insert(self):
+        """Execute an INSERT via ZeroDB tables API."""
+        body = {
+            "table": self._table,
+            "operation": "insert",
+            "rows": self._data,
+        }
+
+        resp = self._session.post(f"{self._tables_url}/insert", json=body)
+        resp.raise_for_status()
+        result = resp.json()
+
+        inserted = result.get("rows", result.get("data", self._data))
+        return APIResponse(data=inserted, status_code=resp.status_code)
+
+    def _execute_update(self):
+        """Execute an UPDATE via ZeroDB tables API."""
+        body = {
+            "table": self._table,
+            "operation": "update",
+            "data": self._data,
+            "filters": self._filters,
+        }
+
+        resp = self._session.post(f"{self._tables_url}/update", json=body)
+        resp.raise_for_status()
+        result = resp.json()
+
+        updated = result.get("rows", result.get("data", []))
+        return APIResponse(data=updated, status_code=resp.status_code)
+
+    def _execute_upsert(self):
+        """Execute an UPSERT via ZeroDB tables API."""
+        body = {
+            "table": self._table,
+            "operation": "upsert",
+            "rows": self._data,
+        }
+
+        resp = self._session.post(f"{self._tables_url}/upsert", json=body)
+        resp.raise_for_status()
+        result = resp.json()
+
+        upserted = result.get("rows", result.get("data", self._data))
+        return APIResponse(data=upserted, status_code=resp.status_code)
+
+    def _execute_delete(self):
+        """Execute a DELETE via ZeroDB tables API."""
+        body = {
+            "table": self._table,
+            "operation": "delete",
+            "filters": self._filters,
+        }
+
+        resp = self._session.post(f"{self._tables_url}/delete", json=body)
+        resp.raise_for_status()
+        result = resp.json()
+
+        deleted = result.get("rows", result.get("data", []))
+        count = result.get("count")
+        return APIResponse(data=deleted, count=count, status_code=resp.status_code)

zerodb_supabase/storage.py

@@ -0,0 +1,299 @@
+"""
+StorageClient -- Supabase Storage-compatible interface backed by ZeroDB files API.
+
+    client.storage.from_('avatars').upload('avatar.png', file_data)
+    url = client.storage.from_('avatars').get_public_url('avatar.png')
+    client.storage.from_('avatars').download('avatar.png')
+"""
+
+
+class StorageFileResponse:
+    """Response wrapper for storage operations."""
+
+    def __init__(self, data=None, path=None, status_code=200):
+        self.data = data
+        self.path = path
+        self.status_code = status_code
+
+    def __repr__(self):
+        return f"StorageFileResponse(path={self.path!r})"
+
+
+class StorageBucket:
+    """Supabase StorageBucket-compatible interface for a single bucket.
+
+    Maps to ZeroDB files API with bucket prefix as directory.
+    """
+
+    def __init__(self, session, files_url, bucket_name):
+        self._session = session
+        self._files_url = files_url
+        self._bucket = bucket_name
+
+    def _file_path(self, path):
+        """Build full file path with bucket prefix."""
+        return f"{self._bucket}/{path}"
+
+    def upload(self, path, file_data, file_options=None):
+        """Upload a file to the bucket.
+
+        Args:
+            path: File path within the bucket.
+            file_data: File content (bytes or file-like object).
+            file_options: Optional dict with content_type, cache_control, etc.
+
+        Returns:
+            StorageFileResponse with upload result.
+        """
+        full_path = self._file_path(path)
+        content_type = "application/octet-stream"
+        if file_options and "content_type" in file_options:
+            content_type = file_options["content_type"]
+        elif file_options and "contentType" in file_options:
+            content_type = file_options["contentType"]
+
+        # Use multipart upload for ZeroDB files API
+        files = {"file": (path, file_data, content_type)}
+        data = {"path": full_path}
+
+        # Temporarily remove JSON content-type for multipart
+        headers = dict(self._session.headers)
+        headers.pop("Content-Type", None)
+
+        resp = self._session.post(
+            f"{self._files_url}/upload",
+            files=files,
+            data=data,
+            headers=headers,
+        )
+        resp.raise_for_status()
+        result = resp.json()
+
+        return StorageFileResponse(
+            data=result,
+            path=full_path,
+            status_code=resp.status_code,
+        )
+
+    def download(self, path):
+        """Download a file from the bucket.
+
+        Args:
+            path: File path within the bucket.
+
+        Returns:
+            bytes -- file content.
+        """
+        full_path = self._file_path(path)
+        resp = self._session.get(
+            f"{self._files_url}/download",
+            params={"path": full_path},
+        )
+        resp.raise_for_status()
+        return resp.content
+
+    def get_public_url(self, path):
+        """Get a public URL for a file.
+
+        Args:
+            path: File path within the bucket.
+
+        Returns:
+            str -- public URL.
+        """
+        full_path = self._file_path(path)
+        resp = self._session.post(
+            f"{self._files_url}/url",
+            json={"path": full_path},
+        )
+        resp.raise_for_status()
+        result = resp.json()
+        return result.get("url", result.get("public_url", ""))
+
+    def create_signed_url(self, path, expires_in=3600):
+        """Create a signed URL for temporary access.
+
+        Args:
+            path: File path within the bucket.
+            expires_in: Seconds until expiration (default 1 hour).
+
+        Returns:
+            dict with signedURL.
+        """
+        full_path = self._file_path(path)
+        resp = self._session.post(
+            f"{self._files_url}/url",
+            json={"path": full_path, "expires_in": expires_in},
+        )
+        resp.raise_for_status()
+        result = resp.json()
+        return {"signedURL": result.get("url", result.get("signed_url", ""))}
+
+    def remove(self, paths):
+        """Remove file(s) from the bucket.
+
+        Args:
+            paths: List of file paths to remove.
+
+        Returns:
+            list of removed file info.
+        """
+        full_paths = [self._file_path(p) for p in paths]
+        resp = self._session.post(
+            f"{self._files_url}/delete",
+            json={"paths": full_paths},
+        )
+        resp.raise_for_status()
+        return resp.json()
+
+    def list(self, path="", limit=100, offset=0, sort_by=None):
+        """List files in the bucket.
+
+        Args:
+            path: Directory path prefix.
+            limit: Max results.
+            offset: Pagination offset.
+            sort_by: Dict with column and order.
+
+        Returns:
+            list of file metadata dicts.
+        """
+        prefix = self._file_path(path) if path else self._bucket
+        resp = self._session.get(
+            f"{self._files_url}/list",
+            params={"prefix": prefix, "limit": limit, "offset": offset},
+        )
+        resp.raise_for_status()
+        result = resp.json()
+        return result.get("files", result if isinstance(result, list) else [])
+
+    def move(self, from_path, to_path):
+        """Move/rename a file within the bucket.
+
+        Args:
+            from_path: Source file path.
+            to_path: Destination file path.
+
+        Returns:
+            dict with result.
+        """
+        resp = self._session.post(
+            f"{self._files_url}/move",
+            json={
+                "from": self._file_path(from_path),
+                "to": self._file_path(to_path),
+            },
+        )
+        resp.raise_for_status()
+        return resp.json()
+
+    def copy(self, from_path, to_path):
+        """Copy a file within the bucket.
+
+        Args:
+            from_path: Source file path.
+            to_path: Destination file path.
+
+        Returns:
+            dict with result.
+        """
+        resp = self._session.post(
+            f"{self._files_url}/copy",
+            json={
+                "from": self._file_path(from_path),
+                "to": self._file_path(to_path),
+            },
+        )
+        resp.raise_for_status()
+        return resp.json()
+
+
+class StorageClient:
+    """Supabase StorageClient-compatible interface.
+
+    Usage:
+        client.storage.from_('bucket-name').upload(...)
+    """
+
+    def __init__(self, session, files_url):
+        self._session = session
+        self._files_url = files_url
+
+    def from_(self, bucket_name):
+        """Get a StorageBucket instance for the named bucket.
+
+        Args:
+            bucket_name: Name of the storage bucket.
+
+        Returns:
+            StorageBucket instance.
+        """
+        return StorageBucket(self._session, self._files_url, bucket_name)
+
+    def list_buckets(self):
+        """List all buckets.
+
+        Returns:
+            list of bucket info dicts.
+        """
+        resp = self._session.get(f"{self._files_url}/buckets")
+        resp.raise_for_status()
+        return resp.json()
+
+    def get_bucket(self, bucket_id):
+        """Get bucket info by ID.
+
+        Args:
+            bucket_id: Bucket name/ID.
+
+        Returns:
+            dict with bucket info.
+        """
+        resp = self._session.get(f"{self._files_url}/buckets/{bucket_id}")
+        resp.raise_for_status()
+        return resp.json()
+
+    def create_bucket(self, bucket_id, options=None):
+        """Create a new bucket.
+
+        Args:
+            bucket_id: Bucket name.
+            options: Optional dict with public, file_size_limit, etc.
+
+        Returns:
+            dict with created bucket info.
+        """
+        body = {"name": bucket_id}
+        if options:
+            body.update(options)
+        resp = self._session.post(f"{self._files_url}/buckets", json=body)
+        resp.raise_for_status()
+        return resp.json()
+
+    def delete_bucket(self, bucket_id):
+        """Delete a bucket.
+
+        Args:
+            bucket_id: Bucket name/ID.
+
+        Returns:
+            dict with result.
+        """
+        resp = self._session.delete(f"{self._files_url}/buckets/{bucket_id}")
+        resp.raise_for_status()
+        return resp.json()
+
+    def empty_bucket(self, bucket_id):
+        """Empty all files in a bucket.
+
+        Args:
+            bucket_id: Bucket name/ID.
+
+        Returns:
+            dict with result.
+        """
+        resp = self._session.post(
+            f"{self._files_url}/buckets/{bucket_id}/empty"
+        )
+        resp.raise_for_status()
+        return resp.json()

zerodb_supabase-0.1.0.dist-info/METADATA

@@ -0,0 +1,244 @@
+Metadata-Version: 2.4
+Name: zerodb-supabase
+Version: 0.1.0
+Summary: Drop-in Supabase Python client replacement backed by ZeroDB. Same API, free cloud database.
+Author-email: AINative Studio <dev@ainative.studio>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/AINative-Studio/zerodb-supabase
+Project-URL: Documentation, https://docs.ainative.studio
+Project-URL: Repository, https://github.com/AINative-Studio/zerodb-supabase
+Project-URL: Issues, https://github.com/AINative-Studio/zerodb-supabase/issues
+Keywords: supabase,supabase-alternative,supabase-py,supabase-python,supabase-client,database,postgres,rest-api,zerodb,ainative,baas,backend-as-a-service,storage,file-storage,s3-compatible,edge-functions,serverless-functions,realtime,vector-database,embeddings,ai-database,free-database,firebase-alternative,neon-alternative,planetscale-alternative,mcp,claude,cursor
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Database
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28
+Dynamic: license-file
+
+# zerodb-supabase
+
+**Drop-in replacement for [supabase-py](https://pypi.org/project/supabase/) backed by ZeroDB.**
+
+Same API. Free cloud database. No Supabase account needed.
+
+[![PyPI](https://img.shields.io/pypi/v/zerodb-supabase)](https://pypi.org/project/zerodb-supabase/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Why switch?
+
+| | supabase-py | zerodb-supabase |
+|---|---|---|
+| **Database** | Supabase Cloud (paid after free tier) | ZeroDB (free tier) |
+| **Storage** | Supabase Storage (limited) | ZeroDB S3-compatible (generous) |
+| **Functions** | Edge Functions (Deno only) | ZeroDB Functions (Python, JS, TS) |
+| **Provisioning** | Manual dashboard setup | Auto-provision on first use |
+| **Vectors** | pgvector extension | Built-in vector search |
+| **AI Memory** | Not available | ZeroMemory cognitive memory |
+| **License** | Apache-2.0 | MIT |
+
+## Installation
+
+```bash
+pip install zerodb-supabase
+```
+
+## Migration (30 seconds)
+
+Change one import:
+
+```python
+# Before
+from supabase import create_client
+
+# After
+from zerodb_supabase import create_client
+```
+
+That's it. Every method works the same.
+
+## Quick Start
+
+```python
+from zerodb_supabase import create_client
+
+# Auto-provisions a free ZeroDB project on first use
+client = create_client()
+
+# Query data
+data = client.table('users').select('*').eq('active', True).execute()
+print(data.data)  # [{'id': 1, 'name': 'Alice', 'active': True}, ...]
+
+# Insert data
+client.table('users').insert({
+    'name': 'Alice',
+    'email': 'alice@example.com'
+}).execute()
+
+# Update data
+client.table('users').update({
+    'name': 'Alice Updated'
+}).eq('id', 1).execute()
+
+# Delete data
+client.table('users').delete().eq('id', 1).execute()
+
+# Storage (S3-compatible)
+client.storage.from_('avatars').upload('avatar.png', open('avatar.png', 'rb'))
+url = client.storage.from_('avatars').get_public_url('avatar.png')
+
+# Functions (ZeroDB Functions)
+result = client.functions.invoke('process-upload', {'file_id': '123'})
+print(result.data)
+```
+
+## API Reference
+
+### `create_client(supabase_url=None, supabase_key=None, **kwargs)`
+
+Create a client. Credentials resolved in order:
+1. Constructor arguments (`api_key`, `project_id`)
+2. Supabase-compatible args (`supabase_key` used as API key)
+3. Environment variables (`ZERODB_API_KEY`, `ZERODB_PROJECT_ID`)
+4. Config file (`~/.zerodb/config.json`)
+5. Auto-provision (free, no signup)
+
+### Query Builder
+
+| Method | Description |
+|--------|-------------|
+| `table(name).select('*')` | Select rows |
+| `table(name).insert(data)` | Insert row(s) |
+| `table(name).update(data)` | Update rows |
+| `table(name).upsert(data)` | Insert or update |
+| `table(name).delete()` | Delete rows |
+
+### Filters (Chainable)
+
+| Method | SQL Equivalent |
+|--------|---------------|
+| `.eq(col, val)` | `WHERE col = val` |
+| `.neq(col, val)` | `WHERE col != val` |
+| `.gt(col, val)` | `WHERE col > val` |
+| `.gte(col, val)` | `WHERE col >= val` |
+| `.lt(col, val)` | `WHERE col < val` |
+| `.lte(col, val)` | `WHERE col <= val` |
+| `.like(col, pattern)` | `WHERE col LIKE pattern` |
+| `.ilike(col, pattern)` | `WHERE col ILIKE pattern` |
+| `.is_(col, val)` | `WHERE col IS val` |
+| `.in_(col, list)` | `WHERE col IN (list)` |
+| `.contains(col, val)` | `WHERE col @> val` |
+| `.not_(col, op, val)` | Negate filter |
+
+### Modifiers
+
+| Method | Description |
+|--------|-------------|
+| `.order(col, desc=False)` | Order results |
+| `.limit(n)` | Limit results |
+| `.offset(n)` | Skip rows |
+| `.range(start, end)` | Row range |
+| `.single()` | Return one row |
+| `.maybe_single()` | Return one or None |
+
+### Storage
+
+```python
+bucket = client.storage.from_('bucket-name')
+bucket.upload('path/file.png', file_data)
+bucket.download('path/file.png')
+bucket.get_public_url('path/file.png')
+bucket.create_signed_url('path/file.png', expires_in=3600)
+bucket.remove(['file1.png', 'file2.png'])
+bucket.list()
+bucket.move('old.png', 'new.png')
+bucket.copy('src.png', 'dst.png')
+```
+
+### Functions
+
+```python
+# Invoke a function
+result = client.functions.invoke('function-name', {'key': 'value'})
+
+# List functions
+functions = client.functions.list()
+
+# RPC shorthand
+result = client.rpc('function-name', {'param': 'value'})
+```
+
+## Configuration
+
+### Environment Variables
+
+```bash
+export ZERODB_API_KEY="your-api-key"
+export ZERODB_PROJECT_ID="your-project-id"
+# Optional: custom endpoint
+export ZERODB_BASE_URL="https://api.ainative.studio"
+```
+
+### Config File
+
+```json
+// ~/.zerodb/config.json
+{
+  "api_key": "your-api-key",
+  "project_id": "your-project-id"
+}
+```
+
+### Auto-Provisioning
+
+If no credentials are found, `zerodb-supabase` automatically creates a free ZeroDB project. Credentials are saved to `~/.zerodb/config.json` for future use.
+
+## Supabase Migration Guide
+
+### 1. Install
+
+```bash
+pip uninstall supabase
+pip install zerodb-supabase
+```
+
+### 2. Update imports
+
+```python
+# Before
+from supabase import create_client, Client
+
+# After
+from zerodb_supabase import create_client, Client
+```
+
+### 3. Remove Supabase config
+
+No more `SUPABASE_URL` or `SUPABASE_KEY` environment variables needed. ZeroDB auto-provisions.
+
+### 4. That's it
+
+All your queries, storage calls, and function invocations work unchanged.
+
+---
+
+**Built by [AINative Studio](https://ainative.studio)**
+
+Free database for AI agents. Auto-provisions in 200ms.
+
+[Get started](https://ainative.studio) | [Documentation](https://docs.ainative.studio) | [GitHub](https://github.com/AINative-Studio/zerodb-supabase)
+
+## License
+
+MIT

zerodb_supabase-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+zerodb_supabase/__init__.py,sha256=T_PgFXlmZt_EsTLKJVClq63mtdTOwxQrndjXfgFA7Sw,788
+zerodb_supabase/client.py,sha256=Sc0Qu0ssUlzouDQuROCZ2yzWjBxJqmVXtaDrymPL9Zk,3645
+zerodb_supabase/functions.py,sha256=_mB-K_HqZ534GuNT9y_Aaf2wxJR-q3_inRfGXJNgDDI,3493
+zerodb_supabase/provision.py,sha256=oKSDHdM06DkGOCC7zTFEGUQ1c84j5Uf3h59cNfuEyMU,3053
+zerodb_supabase/query.py,sha256=8sqkBZt9p3w2LZYllZRZUfPJfV2pFei9WWKv0In8q1Y,12077
+zerodb_supabase/storage.py,sha256=FV2uyNbkClpmM4eypWyxtkxgbpuq9aliZVtI1NLvRxk,8511
+zerodb_supabase-0.1.0.dist-info/licenses/LICENSE,sha256=-3M2h1U80S6mPyiuvRG25A0l1xZGpa7eO43lysBIzBY,1072
+zerodb_supabase-0.1.0.dist-info/METADATA,sha256=LajhM0QJZu8yclixS0DYe49ArU50HwwwXf2sttihJtI,7162
+zerodb_supabase-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+zerodb_supabase-0.1.0.dist-info/top_level.txt,sha256=1hoz3TjOnTShLqfWGbYtXrrkXWv1pb7FU2orKc-2ZSg,16
+zerodb_supabase-0.1.0.dist-info/RECORD,,

zerodb_supabase-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

zerodb_supabase-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AINative Studio
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

zerodb_supabase-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+zerodb_supabase