Connecting Python Apps with Supabase: A Complete Guide

Supabase is an open-source Firebase alternative that provides a powerful PostgreSQL database, authentication, and storage solutions. This guide will show you how to integrate it with Python applications.

Introduction

Modern applications require robust backend services for data storage, user authentication, and file handling. Supabase offers these features with an excellent developer experience. In this guide, we’ll explore how to connect Python applications with Supabase’s core services.

Prerequisites

Before we begin, ensure you have:

Python 3.7 or higher installed
A Supabase account (free tier available)
Basic knowledge of Python and SQL
pip package manager

Setting Up Supabase with Python

First, install the required packages:

pip install supabase-py python-dotenv

Create a .env file to store your Supabase credentials:

SUPABASE_URL=your_supabase_project_url
SUPABASE_KEY=your_supabase_anon_key

Here’s the basic setup code:

import os
from supabase import create_client, Client
from dotenv import load_dotenv

# Load environment variables
load_dotenv()

# Initialize Supabase client
supabase: Client = create_client(
    os.getenv("SUPABASE_URL"),
    os.getenv("SUPABASE_KEY")
)

Working with Supabase PostgreSQL

Creating Tables

You can create tables using Supabase’s web interface or SQL:

CREATE TABLE tasks (
    id SERIAL PRIMARY KEY,
    title VARCHAR(255) NOT NULL,
    description TEXT,
    status VARCHAR(50) DEFAULT 'pending',
    created_at TIMESTAMP WITH TIME ZONE DEFAULT TIMEZONE('utc', NOW())
);

CRUD Operations in Python

Here’s how to perform basic CRUD operations:

# Create a new task
def create_task(title: str, description: str) -> dict:
    return supabase.table('tasks').insert({
        "title": title,
        "description": description
    }).execute()

# Read tasks
def get_tasks():
    return supabase.table('tasks').select("*").execute()

# Update a task
def update_task(task_id: int, status: str):
    return supabase.table('tasks').update(
        {"status": status}
    ).eq("id", task_id).execute()

# Delete a task
def delete_task(task_id: int):
    return supabase.table('tasks').delete().eq("id", task_id).execute()

Handling File Storage

Supabase Storage provides an easy way to manage files:

# Upload a file
def upload_file(bucket_name: str, file_path: str, file_name: str):
    with open(file_path, 'rb') as f:
        return supabase.storage.from_(bucket_name).upload(
            file_name,
            f
        )

# Download a file
def download_file(bucket_name: str, file_path: str, save_path: str):
    return supabase.storage.from_(bucket_name).download(
        file_path,
        save_path
    )

# List files in a bucket
def list_files(bucket_name: str):
    return supabase.storage.from_(bucket_name).list()

Authentication and User Management

Supabase provides built-in authentication:

# Sign up a new user
def sign_up(email: str, password: str):
    return supabase.auth.sign_up({
        "email": email,
        "password": password
    })

# Sign in a user
def sign_in(email: str, password: str):
    return supabase.auth.sign_in_with_password({
        "email": email,
        "password": password
    })

# Sign out
def sign_out():
    return supabase.auth.sign_out()

Real-time Updates

Subscribe to real-time database changes:

def subscribe_to_changes():
    def handle_change(event):
        print(f"Change received: {event}")

    return supabase.table('tasks').on('*', handle_change).subscribe()

Best Practices and Tips

Error Handling: Always implement proper error handling:

try:
    result = supabase.table('tasks').select("*").execute()
except Exception as e:
    print(f"An error occurred: {str(e)}")

Connection Management: Reuse the Supabase client instead of creating new connections.
Environment Variables: Never hardcode credentials; use environment variables.
Rate Limiting: Be mindful of rate limits, especially in the free tier.
Batch Operations: Use batch operations for better performance:

# Batch insert
tasks = [
    {"title": "Task 1", "description": "Description 1"},
    {"title": "Task 2", "description": "Description 2"}
]
result = supabase.table('tasks').insert(tasks).execute()

Common Challenges and Solutions

Challenge 1: Connection Timeouts

Solution: Implement retry logic with exponential backoff:

from tenacity import retry, stop_after_attempt, wait_exponential

@retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=4, max=10))
def fetch_data_with_retry():
    return supabase.table('tasks').select("*").execute()

Challenge 2: Large File Uploads

Solution: Split large files into chunks:

def upload_large_file(bucket_name: str, file_path: str, chunk_size=1024*1024):
    with open(file_path, 'rb') as f:
        while chunk := f.read(chunk_size):
            # Upload chunk
            pass

Conclusion

Supabase provides a powerful backend-as-a-service solution that works seamlessly with Python applications. Its combination of PostgreSQL database, authentication, and storage services makes it an excellent choice for modern web applications. By following the patterns and practices outlined in this guide, you can build robust and scalable applications with Python and Supabase.

Remember to check the official Supabase documentation and Python client library documentation for the most up-to-date information and advanced features.