Supabase Functions Python

https://github.com/supabase/functions-py
Admin
A Python library for interacting with Supabase Functions, enabling easy deployment and invocation of...
Tokens:13,497
Snippets:156
Trust Score:10
License:MIT
Update:3 months ago
Show doc for...
Tokens:
Raw
### Initialize SyncFunctionsClient

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/api-reference/factory.md

Example of instantiating and using a synchronous client.

```python
from supabase_functions import create_client

client = create_client(
    url="https://project.functions.supabase.co",
    headers={"Authorization": "Bearer token"},
    is_async=False
)
result = client.invoke("hello-world")
print(result)
```

--------------------------------

### Initialize AsyncFunctionsClient

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/api-reference/factory.md

Example of instantiating and using an asynchronous client.

```python
import asyncio
from supabase_functions import create_client

async def main():
    client = create_client(
        url="https://project.functions.supabase.co",
        headers={"Authorization": "Bearer token"},
        is_async=True
    )
    result = await client.invoke("hello-world")
    print(result)

asyncio.run(main())
```

--------------------------------

### Install supabase_functions

Source: https://github.com/supabase/functions-py/blob/main/README.md

Use pip to install the library in your Python environment.

```bash
pip3 install supabase_functions
```

--------------------------------

### Retrieve Library Version

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/configuration.md

Import the version constant directly from the library to check the current installed version.

```python
from supabase_functions.version import __version__

print(__version__)  # "0.10.1"
```

--------------------------------

### Invoke Edge Function

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/api-reference/sync-functions-client.md

Examples for invoking Supabase Edge Functions with different configurations, including basic calls, JSON payloads, region specification, and error handling.

```python
from supabase_functions import SyncFunctionsClient

client = SyncFunctionsClient(
    url="https://project.functions.supabase.co",
    headers={"Authorization": "Bearer token"}
)

# Invoke with no parameters
result = client.invoke("hello-world")
print(result)
```

```python
client = SyncFunctionsClient(
    url="https://project.functions.supabase.co",
    headers={"Authorization": "Bearer token"}
)

result = client.invoke(
    "process-data",
    {
        "body": {"userId": 123, "action": "update"},
        "responseType": "json",
        "headers": {"X-Custom-Header": "value"}
    }
)
print(result)  # {"status": "success", ...}
```

```python
from supabase_functions import SyncFunctionsClient, FunctionRegion

client = SyncFunctionsClient(
    url="https://project.functions.supabase.co",
    headers={"Authorization": "Bearer token"}
)

result = client.invoke(
    "geo-aware-function",
    {"region": FunctionRegion.UsEast1}
)
print(result)
```

```python
from supabase_functions import SyncFunctionsClient
from supabase_functions.errors import FunctionsHttpError, FunctionsRelayError

client = SyncFunctionsClient(
    url="https://project.functions.supabase.co",
    headers={"Authorization": "Bearer token"}
)

try:
    result = client.invoke("my-function")
except FunctionsHttpError as e:
    print(f"HTTP error: {e.message} (status: {e.status})")
except FunctionsRelayError as e:
    print(f"Relay error: {e.message}")
```

--------------------------------

### Handle FunctionsHttpError in Python

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/errors.md

Example of catching and accessing attributes of a FunctionsHttpError when invoking an Edge Function.

```python
from supabase_functions import SyncFunctionsClient
from supabase_functions.errors import FunctionsHttpError

client = SyncFunctionsClient(
    url="https://project.functions.supabase.co",
    headers={}
)

try:
    # This will raise FunctionsHttpError if the function returns 404 or 500
    client.invoke("nonexistent-function")
except FunctionsHttpError as e:
    print(f"HTTP Error: {e.message}")
    print(f"Status: {e.status}")
    print(f"Name: {e.name}")
    error_dict = e.to_dict()
```

--------------------------------

### Initialize Client via Factory

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/overview.md

Use the create_client factory to dynamically instantiate either an async or sync client.

```python
from supabase_functions import create_client

def get_client(use_async: bool):
    return create_client(
        url="https://project.functions.supabase.co",
        headers={"Authorization": "Bearer token"},
        is_async=use_async
    )
```

--------------------------------

### Initialize client with environment variables

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/configuration.md

Manually retrieve configuration values from environment variables using os.getenv before passing them to the client constructor.

```python
import os
from supabase_functions import SyncFunctionsClient

url = os.getenv("SUPABASE_FUNCTIONS_URL")
token = os.getenv("SUPABASE_AUTH_TOKEN")

client = SyncFunctionsClient(
    url=url,
    headers={"Authorization": f"Bearer {token}"}
)
```

--------------------------------

### Initialize SyncFunctionsClient with Headers

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/configuration.md

Configure the client with a base URL and required authorization headers. Additional custom headers can be included in the dictionary.

```python
from supabase_functions import SyncFunctionsClient

headers = {
    "Authorization": "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
    "X-Custom-Header": "custom-value"  # Additional headers allowed
}

client = SyncFunctionsClient(
    url="https://project.functions.supabase.co",
    headers=headers
)
```

--------------------------------

### create_client(url, headers, is_async, verify)

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/INDEX.md

Factory function to instantiate a new Functions client.

```APIDOC
## create_client(url, headers, *, is_async, verify=True)

### Description
Creates and returns an instance of either `AsyncFunctionsClient` or `SyncFunctionsClient`.

### Parameters
- **url** (str) - Required - The base URL of the Supabase functions service.
- **headers** (dict) - Required - Default headers for requests.
- **is_async** (bool) - Required - Determines if the returned client is asynchronous.
- **verify** (bool) - Optional - Whether to verify SSL certificates.
```

--------------------------------

### Invoke a Supabase Edge Function

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/api-reference/sync-functions-client.md

Demonstrates initializing the client and invoking a function named 'hello-world'.

```python
from supabase_functions import SyncFunctionsClient

client = SyncFunctionsClient(
    url="https://project_ref.functions.supabase.co",
    headers={"Authorization": "Bearer eyJhbGc..."}
)

result = client.invoke("hello-world")
print(result)
```

--------------------------------

### create_client(url, headers, *, is_async, verify=True)

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/api-reference/factory.md

Initializes and returns a Supabase Functions client. The return type is determined by the is_async parameter.

```APIDOC
## create_client

### Description
Creates a new Supabase Functions client instance. This factory function supports both synchronous and asynchronous clients.

### Signature
`create_client(url: str, headers: dict[str, str], *, is_async: bool, verify: bool = True) -> Union[AsyncFunctionsClient, SyncFunctionsClient]`

### Parameters
- **url** (str) - Required - Base URL of the Supabase Functions endpoint.
- **headers** (dict[str, str]) - Required - HTTP headers to include with all requests.
- **is_async** (bool) - Required - If True, returns AsyncFunctionsClient; if False, returns SyncFunctionsClient.
- **verify** (bool) - Optional - SSL certificate verification setting (default: True).

### Returns
- `AsyncFunctionsClient` if `is_async=True`
- `SyncFunctionsClient` if `is_async=False`

### Raises
- `ValueError`: If url is not a valid HTTP or HTTPS URL.
```

--------------------------------

### Dynamic client selection

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/api-reference/factory.md

Demonstrates using the factory to select client type at runtime based on a condition.

```python
from supabase_functions import create_client

def get_client(use_async: bool):
    return create_client(
        url="https://project.functions.supabase.co",
        headers={"Authorization": "Bearer token"},
        is_async=use_async,
        verify=True
    )

# Use the factory based on runtime condition
if some_condition:
    client = get_client(use_async=True)
else:
    client = get_client(use_async=False)
```

--------------------------------

### Client Initialization

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/overview.md

Methods for initializing the Supabase Functions client.

```APIDOC
## Client Initialization

### Description
Clients can be initialized using AsyncFunctionsClient, SyncFunctionsClient, or the create_client factory method.

### Configuration Options
- **url** (str) - Required - Base URL of the functions endpoint.
- **headers** (Dict[str, str]) - Optional - HTTP headers for all requests.
- **http_client** (Client/AsyncClient) - Optional - Custom httpx client for advanced configuration.
```

--------------------------------

### Initialize Sync Functions Client

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/overview.md

Use the SyncFunctionsClient for standard blocking function execution.

```python
from supabase_functions import SyncFunctionsClient

client = SyncFunctionsClient(
    url="https://project.functions.supabase.co",
    headers={"Authorization": "Bearer token"}
)
result = client.invoke("function-name", {"body": data})
```

--------------------------------

### Create client factory method

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/INDEX.md

Factory function to instantiate either an async or sync client.

```python
def create_client(
    url: str,
    headers: dict[str, str],
    *,
    is_async: bool,
    verify: bool = True
) -> Union[AsyncFunctionsClient, SyncFunctionsClient]
```

--------------------------------

### create_client()

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/MANIFEST.txt

Factory function to instantiate a new FunctionsClient.

```APIDOC
## create_client(url, **kwargs)

### Description
Creates a new instance of a FunctionsClient. Supports both sync and async variants based on configuration.

### Parameters
- **url** (str) - Required - The base URL of the Supabase project functions endpoint.
- **kwargs** (dict) - Optional - Additional configuration parameters such as headers, timeout, or region.
```

--------------------------------

### Configure client-level headers

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/configuration.md

Headers defined during client initialization are included in every subsequent request.

```python
client = SyncFunctionsClient(
    url="https://project.functions.supabase.co",
    headers={
        "Authorization": "Bearer token",
        "X-Client-Version": "1.0"
    }
)
# All subsequent invokes include X-Client-Version header
```

--------------------------------

### AsyncFunctionsClient / SyncFunctionsClient Constructor

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/configuration.md

Initializes the client for interacting with Supabase Functions. Both synchronous and asynchronous clients share these parameters.

```APIDOC
## Constructor: AsyncFunctionsClient / SyncFunctionsClient

### Description
Initializes a new client instance to communicate with the Supabase Functions endpoint.

### Parameters
- **url** (str) - Required - Base URL of the Supabase Functions endpoint.
- **headers** (Dict[str, str]) - Required - HTTP headers to include with all requests (e.g., Authorization).
- **timeout** (int) - Optional - Deprecated. Request timeout in seconds.
- **verify** (bool) - Optional - Deprecated. Enable/disable SSL certificate verification.
- **proxy** (str) - Optional - Deprecated. HTTP proxy URL.
- **http_client** (AsyncClient / Client) - Optional - Custom httpx client instance for advanced configuration.
```

--------------------------------

### Initialize SyncFunctionsClient constructor

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/api-reference/sync-functions-client.md

Defines the signature for the SyncFunctionsClient constructor.

```python
SyncFunctionsClient(
    url: str,
    headers: Dict,
    timeout: Optional[int] = None,
    verify: Optional[bool] = None,
    proxy: Optional[str] = None,
    http_client: Optional[Client] = None,
)
```

--------------------------------

### Client constructor signature

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/INDEX.md

Constructor for both AsyncFunctionsClient and SyncFunctionsClient.

```python
# Both AsyncFunctionsClient and SyncFunctionsClient
def __init__(
    self,
    url: str,
    headers: Dict,
    timeout: Optional[int] = None,           # Deprecated
    verify: Optional[bool] = None,           # Deprecated
    proxy: Optional[str] = None,             # Deprecated
    http_client: Optional[Client] = None
) -> None
```

--------------------------------

### create_client()

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/overview.md

Factory function used to instantiate an async or sync client for interacting with Supabase functions.

```APIDOC
## create_client()

### Description
Factory function for creating async or sync clients to interact with Supabase functions.

### Returns
- **Client** (AsyncFunctionsClient | SyncFunctionsClient) - An instance of the requested client type.
```

--------------------------------

### Define create_client overloads

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/api-reference/factory.md

Type-hinting overloads to ensure correct return types for static analysis.

```python
@overload
def create_client(
    url: str, headers: dict[str, str], *, is_async: Literal[True], verify: bool
) -> AsyncFunctionsClient: ...

@overload
def create_client(
    url: str, headers: dict[str, str], *, is_async: Literal[False], verify: bool
) -> SyncFunctionsClient: ...
```

--------------------------------

### Implement Factory Pattern for Client Selection

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/INDEX.md

Use a factory function to conditionally instantiate either an asynchronous or synchronous client based on configuration.

```python
def create(use_async: bool):
    return create_client(
        url=url,
        headers=headers,
        is_async=use_async
    )

if config.use_async:
    client = create(True)
else:
    client = create(False)
```

--------------------------------

### Configure Authentication for SyncFunctionsClient

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/README.md

Set authentication tokens during client initialization or update them dynamically using the set_auth method.

```python
# Set via constructor
client = SyncFunctionsClient(
    url=url,
    headers={"Authorization": "Bearer token"}
)

# Update dynamically
client.set_auth("new-token")
```

--------------------------------

### Configure Custom HTTP Client

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/overview.md

Inject a custom httpx client to manage advanced settings like timeouts or proxies.

```python
from httpx import Client, Timeout
from supabase_functions import SyncFunctionsClient

custom_client = Client(timeout=Timeout(30))
client = SyncFunctionsClient(
    url="https://project.functions.supabase.co",
    headers={"Authorization": "Bearer token"},
    http_client=custom_client
)
```

--------------------------------

### SyncFunctionsClient Configuration

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/INDEX.md

Methods for configuring the client instance, including authentication and custom HTTP client injection.

```APIDOC
## SyncFunctionsClient Configuration

### Description
Methods to manage client state and dependencies.

### Methods
- **set_auth(token)**: Updates the authorization token used for requests.
- **SyncFunctionsClient(url, headers, http_client)**: Constructor to initialize the client with a specific URL, headers, and an optional custom httpx.Client instance.
```

--------------------------------

### Configure Custom HTTP Client

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/INDEX.md

Pass a custom httpx.Client instance to the SyncFunctionsClient constructor to override default HTTP settings like timeouts.

```python
from httpx import Client, Timeout

custom_client = Client(timeout=Timeout(30))
client = SyncFunctionsClient(
    url=url,
    headers=headers,
    http_client=custom_client
)
```

--------------------------------

### Configure Custom HTTP Client

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/configuration.md

Pass a custom httpx Client instance to the SyncFunctionsClient to manage timeout, SSL verification, and proxy settings.

```python
from httpx import Client, Timeout
from supabase_functions import SyncFunctionsClient

custom_client = Client(
    timeout=Timeout(30),
    verify=True,
    proxy="http://proxy.example.com:8080"
)

client = SyncFunctionsClient(
    url="https://project.functions.supabase.co",
    headers={"Authorization": "Bearer token"},
    http_client=custom_client
)
```

--------------------------------

### SyncFunctionsClient Configuration

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/README.md

Methods for configuring the client, including authentication, SSL, timeouts, and proxies.

```APIDOC
## SyncFunctionsClient Configuration

### Authentication
- **Constructor**: Initialize with `url` and `headers` (e.g., `{"Authorization": "Bearer token"}`).
- **set_auth(token)**: Update the authentication token dynamically.

### SSL/TLS
- Configure via `httpx.Client(verify=True|False)` and pass to `SyncFunctionsClient` constructor as `http_client`.

### Timeouts
- Configure via `httpx.Client(timeout=Timeout(seconds))` and pass to `SyncFunctionsClient` constructor as `http_client`.

### Proxies
- Configure via `httpx.Client(proxy="url")` and pass to `SyncFunctionsClient` constructor as `http_client`.
```

--------------------------------

### Handle SyncClient deprecation

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/api-reference/utilities.md

SyncClient is deprecated; use the standard httpx.Client instead.

```python
class SyncClient(BaseClient):
    def __init__(self, *args, **kwargs)
    def aclose(self) -> None
```

```python
# Do not use this code in new projects
from supabase_functions.utils import SyncClient

client = SyncClient()  # DeprecationWarning
client.aclose()  # DeprecationWarning, calls client.close()
```

```python
from httpx import Client

client = Client()
client.close()
```

--------------------------------

### Configure Network Proxies

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/README.md

Route requests through a proxy server by configuring the httpx Client with a proxy URL.

```python
from httpx import Client

custom_client = Client(proxy="http://proxy.example.com:8080")
client = SyncFunctionsClient(
    url=url,
    headers=headers,
    http_client=custom_client
)
```

--------------------------------

### AsyncFunctionsClient Constructor

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/api-reference/async-functions-client.md

Initializes a new instance of the AsyncFunctionsClient to interact with Supabase Edge Functions.

```APIDOC
## Constructor: AsyncFunctionsClient

### Description
Initializes an asynchronous Supabase Functions client.

### Signature
`AsyncFunctionsClient(url: str, headers: Dict, timeout: Optional[int] = None, verify: Optional[bool] = None, proxy: Optional[str] = None, http_client: Optional[AsyncClient] = None)`

### Parameters
- **url** (str) - Required - Base URL of the Supabase Functions endpoint.
- **headers** (Dict) - Required - HTTP headers to include with all requests.
- **timeout** (Optional[int]) - Optional - Deprecated. Time in seconds for request timeout.
- **verify** (Optional[bool]) - Optional - Deprecated. Whether to verify SSL certificates.
- **proxy** (Optional[str]) - Optional - Deprecated. Proxy URL for requests.
- **http_client** (Optional[AsyncClient]) - Optional - Custom httpx.AsyncClient instance.

### Raises
- **ValueError**: If url is not a valid HTTP or HTTPS URL.
```

--------------------------------

### Invoking an Edge Function

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/api-reference/async-functions-client.md

Demonstrates initializing the client and invoking a function asynchronously.

```python
import asyncio
from supabase_functions import AsyncFunctionsClient

async def main():
    client = AsyncFunctionsClient(
        url="https://project_ref.functions.supabase.co",
        headers={"Authorization": "Bearer eyJhbGc..."}
    )
    
    result = await client.invoke("hello-world")
    print(result)

asyncio.run(main())
```

--------------------------------

### Invoke function with options

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/configuration.md

Demonstrates passing body, headers, response type, and region to the invoke method.

```python
from supabase_functions import SyncFunctionsClient, FunctionRegion

client = SyncFunctionsClient(
    url="https://project.functions.supabase.co",
    headers={"Authorization": "Bearer token"}
)

result = client.invoke(
    "my-function",
    {
        "body": {"userId": 123, "action": "create"},
        "headers": {"X-Request-Id": "abc123"},
        "responseType": "json",
        "region": FunctionRegion.UsEast1
    }
)
```

--------------------------------

### Configure SSL/TLS Verification

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/README.md

Customize SSL verification by passing a pre-configured httpx Client to the SyncFunctionsClient. Disabling verification is not recommended for production environments.

```python
from httpx import Client

# Enable (default)
custom_client = Client(verify=True)

# Disable (not recommended for production)
custom_client = Client(verify=False)

client = SyncFunctionsClient(
    url=url,
    headers=headers,
    http_client=custom_client
)
```

--------------------------------

### AsyncFunctionsClient Constructor Signature

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/api-reference/async-functions-client.md

Defines the initialization parameters for the AsyncFunctionsClient.

```python
AsyncFunctionsClient(
    url: str,
    headers: Dict,
    timeout: Optional[int] = None,
    verify: Optional[bool] = None,
    proxy: Optional[str] = None,
    http_client: Optional[AsyncClient] = None,
)
```

--------------------------------

### Migrate from deprecated client parameters to custom httpx Client

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/INDEX.md

Replace deprecated parameters like timeout, verify, and proxy by injecting a custom httpx.Client instance into the SyncFunctionsClient.

```python
# Old (deprecated)
client = SyncFunctionsClient(
    url=url,
    headers=headers,
    timeout=30,
    verify=True,
    proxy="http://proxy:8080"
)

# New (recommended)
from httpx import Client, Timeout

custom_client = Client(
    timeout=Timeout(30),
    verify=True,
    proxy="http://proxy:8080"
)
client = SyncFunctionsClient(
    url=url,
    headers=headers,
    http_client=custom_client
)
```

--------------------------------

### SyncFunctionsClient Constructor

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/api-reference/sync-functions-client.md

Initializes a new instance of the SyncFunctionsClient to manage synchronous requests to Supabase Edge Functions.

```APIDOC
## SyncFunctionsClient.__init__

### Description
Initializes a synchronous Supabase Functions client. This client extends httpx.Client to provide function-specific request handling.

### Signature
SyncFunctionsClient(url: str, headers: Dict, timeout: Optional[int] = None, verify: Optional[bool] = None, proxy: Optional[str] = None, http_client: Optional[Client] = None)

### Parameters
- **url** (str) - Required - Base URL of the Supabase Functions endpoint.
- **headers** (Dict) - Required - HTTP headers to include with all requests.
- **timeout** (Optional[int]) - Optional - Deprecated. Time in seconds for request timeout.
- **verify** (Optional[bool]) - Optional - Deprecated. Whether to verify SSL certificates.
- **proxy** (Optional[str]) - Optional - Deprecated. Proxy URL for requests.
- **http_client** (Optional[Client]) - Optional - Custom httpx.Client instance.

### Raises
- **ValueError**: If url is not a valid HTTP or HTTPS URL.
```

--------------------------------

### Invoke Functions with Different Request Types

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/INDEX.md

Demonstrates various ways to invoke functions, including passing text or JSON bodies, omitting the body, and specifying a target region.

```python
# Text body
result1 = client.invoke("fn1", {"body": "text data"})

# JSON body
result2 = client.invoke("fn2", {"body": {"key": "value"}})

# No body
result3 = client.invoke("fn3")

# With region
result4 = client.invoke("fn4", {"region": FunctionRegion.UsEast1})
```

--------------------------------

### Invoke an Edge Function

Source: https://github.com/supabase/functions-py/blob/main/README.md

Initialize the AsyncFunctionsClient and invoke a function using the project URL and function name.

```python
import asyncio
from supabase_functions import AsyncFunctionsClient
async def run_func():
    fc = AsyncFunctionsClient("https://<project_ref>.functions.supabase.co", {})
    res = await fc.invoke("payment-sheet", {"responseType": "json"})

if __name__ == "__main__":
    asyncio.run(run_func())
```

--------------------------------

### Define create_client signature

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/api-reference/factory.md

The primary function signature for creating a Supabase Functions client.

```python
def create_client(
    url: str,
    headers: dict[str, str],
    *,
    is_async: bool,
    verify: bool = True,
) -> Union[AsyncFunctionsClient, SyncFunctionsClient]
```

--------------------------------

### Configure per-request headers

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/configuration.md

Headers provided in invoke_options are merged with client headers for a single request and do not persist.

```python
client = SyncFunctionsClient(
    url="https://project.functions.supabase.co",
    headers={"Authorization": "Bearer token"}
)

# This request includes both Authorization and X-Request-Id
result = client.invoke(
    "my-function",
    {"headers": {"X-Request-Id": "request123"}}
)

# This request includes only Authorization (X-Request-Id not carried over)
result = client.invoke("another-function")
```

--------------------------------

### Handle ValueError in Supabase Functions

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/errors.md

Demonstrates catching ValueError exceptions triggered by invalid client initialization or invalid function names.

```python
from supabase_functions import SyncFunctionsClient

# ValueError: Invalid URL
try:
    client = SyncFunctionsClient(
        url="not-a-url",
        headers={}
    )
except ValueError as e:
    print(e)  # "url must be a valid HTTP URL string"

# ValueError: Invalid function name
client = SyncFunctionsClient(
    url="https://project.functions.supabase.co",
    headers={}
)

try:
    client.invoke("")
except ValueError as e:
    print(e)  # "function_name must a valid string value."
```

--------------------------------

### Utility functions

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/INDEX.md

Helper functions for validating arguments and URLs.

```python
def is_valid_str_arg(target: str) -> bool

def is_http_url(url: str) -> bool
```

--------------------------------

### POST /{function_name}

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/overview.md

Invokes a Supabase function via an HTTP POST request.

```APIDOC
## POST /{function_name}

### Description
Invokes a specific Supabase function by name.

### Method
POST

### Endpoint
/{function_name}

### Parameters
#### Path Parameters
- **function_name** (string) - Required - The name of the function to invoke.

#### Headers
- **Authorization** (string) - Required - Bearer {token}
- **User-Agent** (string) - Required - supabase-py/functions-py v0.10.1
- **Content-Type** (string) - Required - text/plain or application/json
- **x-region** (string) - Optional - The region value for the function execution.

### Response
#### Success Response (2xx)
- **response** (json/bytes) - Parsed based on responseType (json or text/plain).

#### Error Response (4xx/5xx)
- **FunctionsHttpError** - Raised when the server returns a 4xx or 5xx status code.
- **FunctionsRelayError** - Raised when the x-relay-header is set to true.
```

--------------------------------

### Set authentication token

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/INDEX.md

Update the client's authorization token.

```python
def set_auth(self, token: str) -> None
```

--------------------------------

### SyncFunctionsClient.invoke

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/README.md

Invokes a Supabase Edge Function synchronously.

```APIDOC
## invoke(function_name: str, invoke_options: Optional[Dict] = None) -> Union[Dict, bytes]

### Description
Invokes a Supabase Edge Function synchronously and returns the response as a dictionary or bytes.

### Parameters
- **function_name** (str) - Required - The name of the function to invoke.
- **invoke_options** (Optional[Dict]) - Optional - Additional options for the invocation.
```

--------------------------------

### Convert FunctionsError to Dictionary

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/errors.md

Demonstrates how to instantiate a FunctionsError and convert it to a dictionary using to_dict().

```python
from supabase_functions.errors import FunctionsError

error = FunctionsError("Something failed", "CustomError", 500)
error_dict = error.to_dict()
# {"name": "CustomError", "message": "Something failed", "status": 500}
```

--------------------------------

### Initialize FunctionsError Constructor

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/errors.md

Defines the signature for the FunctionsError constructor.

```python
def __init__(self, message: str, name: str, status: int) -> None
```

--------------------------------

### Invoke method signatures

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/INDEX.md

Method signatures for asynchronous and synchronous function invocation.

```python
# Async
async def invoke(
    self,
    function_name: str,
    invoke_options: Optional[Dict] = None
) -> Union[Dict, bytes]

# Sync
def invoke(
    self,
    function_name: str,
    invoke_options: Optional[Dict] = None
) -> Union[Dict, bytes]
```

--------------------------------

### AsyncFunctionsClient.invoke

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/README.md

Invokes a Supabase Edge Function asynchronously.

```APIDOC
## async invoke(function_name: str, invoke_options: Optional[Dict] = None) -> Union[Dict, bytes]

### Description
Invokes a Supabase Edge Function asynchronously and returns the response as a dictionary or bytes.

### Parameters
- **function_name** (str) - Required - The name of the function to invoke.
- **invoke_options** (Optional[Dict]) - Optional - Additional options for the invocation.
```

--------------------------------

### Handling FunctionsRelayError

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/errors.md

Demonstrates how to catch and handle a FunctionsRelayError when invoking a function.

```python
from supabase_functions import SyncFunctionsClient
from supabase_functions.errors import FunctionsRelayError

client = SyncFunctionsClient(
    url="https://project.functions.supabase.co",
    headers={}
)

try:
    client.invoke("my-function")
except FunctionsRelayError as e:
    print(f"Relay Error: {e.message}")
    print(f"Status: {e.status}")
```

--------------------------------

### Handle FunctionsApiErrorDict in error catching

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/types.md

Shows how to convert a caught error to a dictionary using the FunctionsApiErrorDict type.

```python
from supabase_functions import SyncFunctionsClient
from supabase_functions.errors import FunctionsHttpError, FunctionsApiErrorDict

client = SyncFunctionsClient(
    url="https://project.functions.supabase.co",
    headers={}
)

try:
    client.invoke("my-function")
except FunctionsHttpError as e:
    error_dict: FunctionsApiErrorDict = e.to_dict()
    print(error_dict["name"])      # "FunctionsHttpError"
    print(error_dict["message"])   # "Custom error message"
    print(error_dict["status"])    # 500
```

--------------------------------

### Use FunctionRegion in client invocation

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/types.md

Demonstrates using the FunctionRegion enum for region selection during function invocation.

```python
from supabase_functions import SyncFunctionsClient, FunctionRegion

client = SyncFunctionsClient(
    url="https://project.functions.supabase.co",
    headers={"Authorization": "Bearer token"}
)

# Use as enum member
result = client.invoke(
    "my-function",
    {"region": FunctionRegion.UsEast1}
)

# Or convert to string
region_str: str = FunctionRegion.EuWest1.value
print(region_str)  # "eu-west-1"

# Construct from string
region = FunctionRegion("ap-southeast-1")
result = client.invoke("my-function", {"region": region})
```

--------------------------------

### invoke(function_name, invoke_options=None)

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/api-reference/sync-functions-client.md

Invokes a Supabase Edge Function with optional request customization.

```APIDOC
## invoke(function_name, invoke_options=None)

### Description
Invokes a Supabase Edge Function. The function name is used to construct the request path as POST /{function_name}.

### Parameters
- **function_name** (str) - Required - Name of the function to invoke.
- **invoke_options** (Optional[Dict]) - Optional - Configuration for the request.

### invoke_options fields
- **body** (str | Dict) - Optional - Request body. If string, Content-Type is text/plain. If dict, Content-Type is application/json.
- **headers** (Dict[str, str]) - Optional - Additional headers to merge with client headers.
- **responseType** (str) - Optional - How to parse the response. Either "json" or "text/plain".
- **region** (FunctionRegion | str) - Optional - Region where the function should execute.

### Returns
- **Dict** if responseType="json" - Parsed JSON response.
- **bytes** if responseType="text/plain" - Raw response body.

### Raises
- **ValueError** - If function_name is empty or not a valid string.
- **FunctionsHttpError** - If HTTP status code indicates an error (4xx or 5xx).
- **FunctionsRelayError** - If the response has x-relay-header: true header.
```

--------------------------------

### Update Authentication Token

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/INDEX.md

Use set_auth to update the authentication token for an existing SyncFunctionsClient instance.

```python
client = SyncFunctionsClient(url=url, headers={})
client.set_auth("new-token")
```

--------------------------------

### invoke()

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/README.md

The invoke method allows executing functions with optional configuration for body, headers, response type, and region.

```APIDOC
## invoke(body, headers, responseType, region)

### Description
Executes a Supabase function with specified configuration options.

### Parameters
- **body** (str | Dict) - Optional - Request body (text or JSON).
- **headers** (Dict[str, str]) - Optional - Per-request headers.
- **responseType** (str) - Optional - Response format ("json" or "text/plain"). Default: "text/plain".
- **region** (FunctionRegion | str) - Optional - AWS region for execution.
```

--------------------------------

### is_http_url(url: str) -> bool

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/api-reference/utilities.md

Validates that a given string is a valid HTTP or HTTPS URL.

```APIDOC
## is_http_url

### Description
Validates that a value is a valid HTTP or HTTPS URL by parsing the scheme. Returns False for other schemes like FTP or WebSocket.

### Signature
`def is_http_url(url: str) -> bool`

### Parameters
- **url** (str) - Required - The URL string to validate.

### Returns
- **bool** - True if the URL has an 'http' or 'https' scheme, False otherwise.
```

--------------------------------

### Invoke with JSON body and response

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/INDEX.md

Pass a dictionary as the body and specify the responseType to handle JSON data.

```python
result = client.invoke(
    "process",
    {
        "body": {"data": "value"},
        "responseType": "json"
    }
)
```

--------------------------------

### SyncFunctionsClient.invoke()

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/overview.md

Method to invoke a remote function synchronously.

```APIDOC
## SyncFunctionsClient.invoke()

### Description
Invokes a Supabase function by name with specified options synchronously.

### Parameters
- **function_name** (str) - Required - The name of the function to invoke.
- **invoke_options** (dict) - Optional - Configuration for request body format, response parsing, and region routing.
```

--------------------------------

### AsyncFunctionsClient.invoke()

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/overview.md

Method to invoke a remote function asynchronously.

```APIDOC
## AsyncFunctionsClient.invoke()

### Description
Invokes a Supabase function by name with specified options.

### Parameters
- **function_name** (str) - Required - The name of the function to invoke.
- **invoke_options** (dict) - Optional - Configuration for request body format, response parsing, and region routing.
```

--------------------------------

### HTTP Request Format

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/overview.md

The standard structure for POST requests sent to Supabase Functions, including required headers and body placement.

```http
POST /{function_name} HTTP/1.1 or HTTP/2
Host: {base_url}
Authorization: Bearer {token}
User-Agent: supabase-py/functions-py v0.10.1
Content-Type: [text/plain | application/json]
x-region: [region_value]
[additional headers]

[body]
```

--------------------------------

### User-Agent Header Format

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/configuration.md

The client automatically appends this header to all outgoing requests.

```text
User-Agent: supabase-py/functions-py v<version>
```

--------------------------------

### client.invoke(function_name, options)

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/INDEX.md

Invokes a remote function by name with optional request body, headers, response type, and execution region.

```APIDOC
## invoke(function_name, options)

### Description
Invokes a Supabase function. The options parameter allows specifying the request body, headers, expected response type, and the execution region.

### Parameters
- **function_name** (str) - Required - The name of the function to invoke.
- **options** (dict) - Optional - Configuration for the invocation:
  - **body** (str | Dict) - Optional - The request body (text or JSON).
  - **headers** (Dict[str, str]) - Optional - Additional HTTP headers.
  - **responseType** (str) - Optional - Expected response format ("json" or "text/plain").
  - **region** (FunctionRegion | str) - Optional - The AWS region for execution.

### Usage Example
```python
# Invoking with JSON body
result = client.invoke("my-function", {"body": {"key": "value"}})

# Invoking with region
result = client.invoke("my-function", {"region": FunctionRegion.UsEast1})
```
```

--------------------------------

### Disable SSL Verification

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/configuration.md

Use a custom httpx client to disable SSL verification for development environments. This is a security risk and must not be used in production.

```python
from httpx import Client
from supabase_functions import SyncFunctionsClient

custom_client = Client(verify=False)

client = SyncFunctionsClient(
    url="https://project.functions.supabase.co",
    headers={"Authorization": "Bearer token"},
    http_client=custom_client
)
```

--------------------------------

### Invoke a function synchronously

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/INDEX.md

Use SyncFunctionsClient for standard blocking function execution.

```python
from supabase_functions import SyncFunctionsClient

client = SyncFunctionsClient(
    url="https://project.functions.supabase.co",
    headers={"Authorization": "Bearer token"}
)
result = client.invoke("hello")
print(result)
```

--------------------------------

### Catch specific Supabase function errors

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/errors.md

Shows how to catch and handle specific error types including HTTP errors, relay errors, and validation errors.

```python
from supabase_functions import SyncFunctionsClient
from supabase_functions.errors import FunctionsHttpError, FunctionsRelayError

client = SyncFunctionsClient(
    url="https://project.functions.supabase.co",
    headers={"Authorization": "Bearer token"}
)

try:
    result = client.invoke("my-function", {"body": {"data": "value"}})
except FunctionsHttpError as e:
    # Handle HTTP errors (4xx, 5xx)
    print(f"Function returned error: {e.message} (status {e.status})")
except FunctionsRelayError as e:
    # Handle relay infrastructure errors
    print(f"Relay service error: {e.message}")
except ValueError as e:
    # Handle validation errors
    print(f"Invalid request: {e}")
```

--------------------------------

### set_auth(token)

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/api-reference/sync-functions-client.md

Updates the authorization header for the client with a new JWT token.

```APIDOC
## set_auth(token)

### Description
Updates the authorization header with a new JWT token. This token will be used in the Authorization: Bearer <token> header for subsequent requests.

### Parameters
- **token** (str) - Required - JWT token to use for authorization.

### Returns
- None
```

--------------------------------

### FunctionsClient.invoke()

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/MANIFEST.txt

Invokes a Supabase Edge Function. This method is available on both the AsyncFunctionsClient and SyncFunctionsClient.

```APIDOC
## invoke(function_name, invoke_options)

### Description
Invokes a remote Edge Function by name, optionally passing a body and headers.

### Parameters
- **function_name** (str) - Required - The name of the function to invoke.
- **invoke_options** (dict) - Optional - Configuration including body, headers, and responseType.
```

--------------------------------

### Define to_dict Method Signature

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/errors.md

Defines the signature for the to_dict method which returns a dictionary representation of the error.

```python
def to_dict(self) -> FunctionsApiErrorDict
```

--------------------------------

### Send JSON body and handle response

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/README.md

Pass a dictionary as the body and specify responseType to handle JSON payloads.

```python
result = client.invoke(
    "process-data",
    {
        "body": {"userId": 123, "action": "create"},
        "responseType": "json",
        "headers": {"X-Request-Id": "req123"}
    }
)
```

--------------------------------

### is_valid_str_arg(target: str) -> bool

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/api-reference/utilities.md

Validates that a provided value is a non-empty string containing at least one non-whitespace character.

```APIDOC
## is_valid_str_arg

### Description
Validates that a value is a non-empty string. Returns False if the input is None, not a string, empty, or contains only whitespace.

### Signature
`def is_valid_str_arg(target: str) -> bool`

### Parameters
- **target** (str) - Required - The value to validate.

### Returns
- **bool** - True if the target is a non-empty string with at least one non-whitespace character, False otherwise.
```

--------------------------------

### FunctionsClient.set_auth()

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/MANIFEST.txt

Updates the authorization token used for subsequent function invocations.

```APIDOC
## set_auth(token)

### Description
Sets or updates the Bearer token used in the Authorization header for requests.

### Parameters
- **token** (str) - Required - The JWT or API key to use for authentication.
```

--------------------------------

### Invoke a function asynchronously

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/INDEX.md

Use AsyncFunctionsClient for non-blocking function execution.

```python
import asyncio
from supabase_functions import AsyncFunctionsClient

async def main():
    client = AsyncFunctionsClient(
        url="https://project.functions.supabase.co",
        headers={"Authorization": "Bearer token"}
    )
    result = await client.invoke("hello")
    print(result)

asyncio.run(main())
```

--------------------------------

### Access DEFAULT_FUNCTION_CLIENT_TIMEOUT constant

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/api-reference/utilities.md

Represents the default timeout for client requests, though it is currently unused in the library implementation.

```python
DEFAULT_FUNCTION_CLIENT_TIMEOUT = 5
```

--------------------------------

### Validate base64url strings with BASE64URL_REGEX

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/api-reference/utilities.md

Uses a regular expression to validate base64url-encoded strings without padding.

```python
BASE64URL_REGEX = r"^([a-z0-9_-]{4})*($|[a-z0-9_-]{3}$|[a-z0-9_-]{2}$)$"
```

```python
import re
from supabase_functions.utils import BASE64URL_REGEX

pattern = re.compile(BASE64URL_REGEX, re.IGNORECASE)

assert pattern.match("ABCD")
assert pattern.match("abc123")
assert not pattern.match("abc")  # too short
assert not pattern.match("abc!")  # invalid character
```

--------------------------------

### Validate non-empty strings with is_valid_str_arg

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/api-reference/utilities.md

Checks if a value is a non-empty string containing at least one non-whitespace character.

```python
def is_valid_str_arg(target: str) -> bool
```

```python
from supabase_functions.utils import is_valid_str_arg

assert is_valid_str_arg("valid_string") == True
assert is_valid_str_arg("  spaced  ") == True
assert is_valid_str_arg("") == False
assert is_valid_str_arg("   ") == False
assert is_valid_str_arg(None) == False
assert is_valid_str_arg(123) == False
```

--------------------------------

### Validate HTTP URLs with is_http_url

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/api-reference/utilities.md

Verifies that a string is a valid URL with an http or https scheme.

```python
def is_http_url(url: str) -> bool
```

```python
from supabase_functions.utils import is_http_url

assert is_http_url("https://example.com") == True
assert is_http_url("http://localhost:8000") == True
assert is_http_url("https://api.supabase.com") == True
assert is_http_url("ftp://example.com") == False
assert is_http_url("ws://example.com") == False
assert is_http_url("not-a-url") == False
assert is_http_url("") == False
```

--------------------------------

### FunctionsHttpError Constructor

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/errors.md

The constructor for the FunctionsHttpError class.

```python
def __init__(self, message: str, code: int | None = None) -> None
```

--------------------------------

### Handle function errors

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/INDEX.md

Catch specific exceptions for HTTP and relay errors during invocation.

```python
from supabase_functions.errors import FunctionsHttpError, FunctionsRelayError

try:
    result = client.invoke("my-function")
except FunctionsHttpError as e:
    print(f"HTTP Error: {e.message} (status {e.status})")
except FunctionsRelayError as e:
    print(f"Relay Error: {e.message}")
```

--------------------------------

### Invoke with region specification

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/INDEX.md

Target a specific geographic region for function execution using FunctionRegion.

```python
from supabase_functions import FunctionRegion

result = client.invoke(
    "geo-function",
    {"region": FunctionRegion.UsEast1}
)
```

--------------------------------

### Invoke Edge Function

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/api-reference/async-functions-client.md

Invokes a function by name. The method signature supports optional request customization via invoke_options.

```python
async def invoke(
    function_name: str,
    invoke_options: Optional[Dict] = None
) -> Union[Dict, bytes]
```

```python
import asyncio
from supabase_functions import AsyncFunctionsClient

async def main():
    client = AsyncFunctionsClient(
        url="https://project.functions.supabase.co",
        headers={"Authorization": "Bearer token"}
    )
    
    # Invoke with no parameters
    result = await client.invoke("hello-world")
    print(result)

asyncio.run(main())
```

```python
async def main():
    client = AsyncFunctionsClient(
        url="https://project.functions.supabase.co",
        headers={"Authorization": "Bearer token"}
    )
    
    result = await client.invoke(
        "process-data",
        {
            "body": {"userId": 123, "action": "update"},
            "responseType": "json",
            "headers": {"X-Custom-Header": "value"}
        }
    )
    print(result)  # {"status": "success", ...}

asyncio.run(main())
```

```python
from supabase_functions import FunctionRegion

async def main():
    client = AsyncFunctionsClient(
        url="https://project.functions.supabase.co",
        headers={"Authorization": "Bearer token"}
    )
    
    result = await client.invoke(
        "geo-aware-function",
        {"region": FunctionRegion.UsEast1}
    )
    print(result)

asyncio.run(main())
```

```python
from supabase_functions import AsyncFunctionsClient
from supabase_functions.errors import FunctionsHttpError, FunctionsRelayError

async def main():
    client = AsyncFunctionsClient(
        url="https://project.functions.supabase.co",
        headers={"Authorization": "Bearer token"}
    )
    
    try:
        result = await client.invoke("my-function")
    except FunctionsHttpError as e:
        print(f"HTTP error: {e.message} (status: {e.status})")
    except FunctionsRelayError as e:
        print(f"Relay error: {e.message}")

asyncio.run(main())
```

--------------------------------

### Define FunctionRegion enumeration

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/types.md

Represents AWS regions for function execution, inheriting from StrEnum.

```python
class FunctionRegion(StrEnum):
    Any = "any"
    ApNortheast1 = "ap-northeast-1"
    ApNortheast2 = "ap-northeast-2"
    ApSouth1 = "ap-south-1"
    ApSoutheast1 = "ap-southeast-1"
    ApSoutheast2 = "ap-southeast-2"
    CaCentral1 = "ca-central-1"
    EuCentral1 = "eu-central-1"
    EuWest1 = "eu-west-1"
    EuWest2 = "eu-west-2"
    EuWest3 = "eu-west-3"
    SaEast1 = "sa-east-1"
    UsEast1 = "us-east-1"
    UsWest1 = "us-west-1"
    UsWest2 = "us-west-2"
```

--------------------------------

### Serialize error to dictionary

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/errors.md

Converts a FunctionsHttpError instance into a dictionary for easier serialization.

```python
from supabase_functions import SyncFunctionsClient
from supabase_functions.errors import FunctionsHttpError
import json

client = SyncFunctionsClient(
    url="https://project.functions.supabase.co",
    headers={}
)

try:
    client.invoke("my-function")
except FunctionsHttpError as e:
    error_dict = e.to_dict()
    print(json.dumps(error_dict))
    # {"name": "FunctionsHttpError", "message": "...", "status": 500}
```

--------------------------------

### Update Authorization Token

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/api-reference/sync-functions-client.md

Updates the authorization header for subsequent requests using a new JWT token.

```python
client = SyncFunctionsClient(
    url="https://project.functions.supabase.co",
    headers={}
)

# Update token
new_token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
client.set_auth(new_token)
```

--------------------------------

### Define FunctionsApiErrorDict structure

Source: https://github.com/supabase/functions-py/blob/main/_autodocs/types.md

TypedDict definition for error dictionaries returned by error methods.

```python
class FunctionsApiErrorDict(TypedDict):
    name: str
    message: str
    status: int
```
Tokens:
Raw