# Supabase Python Client (Rust-Powered)
🚀 **Ultra-fast, comprehensive Supabase client for Python, powered by Rust**
[](https://badge.fury.io/py/supabase-lib-rs)
[](https://pypi.org/project/supabase-lib-rs/)
[](https://opensource.org/licenses/MIT)
## ✨ Features
- **🔐 Authentication**: Complete auth system with OAuth, MFA, phone auth
- **🗄️ Database**: Advanced PostgreSQL operations with joins, transactions
- **📁 Storage**: File upload, download, and management with transformations
- **⚡ Realtime**: WebSocket subscriptions for live data
- **🔧 Functions**: Edge Functions invocation with streaming support
- **🚀 Performance**: 10x+ faster than pure Python implementations
- **🛡️ Type Safe**: Full type hints for excellent IDE support
- **🌐 Cross-Platform**: Works on Windows, macOS, Linux (x86_64, ARM64)
## 🚀 Quick Start
### Installation
```bash
pip install supabase-lib-rs
```
### Basic Usage
```python
import asyncio
from supabase_lib_rs import Client
async def main():
# Initialize client
client = Client("https://your-project.supabase.co", "your-anon-key")
# Authentication
session = await client.auth.sign_up("user@example.com", "password")
print(f"User created: {session['user']['email']}")
# Database operations
result = await client.database.from_("profiles") \
.select("id, name, email") \
.filter("active", "eq", "true") \
.execute()
print(f"Found {len(result)} active profiles")
# Storage operations
buckets = await client.storage.list_buckets()
print(f"Storage buckets: {[b['name'] for b in buckets]}")
# Edge Functions
response = await client.functions.invoke("hello-world", {"name": "Python"})
print(f"Function response: {response}")
# Run the async function
asyncio.run(main())
```
## 📊 Performance Comparison
| Auth Sign In | 45ms | 4ms | **11.2x** |
| Database Query | 120ms | 8ms | **15x** |
| Storage List | 80ms | 6ms | **13.3x** |
| Function Invoke | 95ms | 7ms | **13.6x** |
_Benchmarks run on MacBook Pro M2, 1000 iterations_
## 🔧 Advanced Usage
### Database Operations
```python
# Complex queries with joins
result = await client.database.from_("posts") \
.select("title, content, profiles(name, avatar_url)") \
.filter("published", "eq", True) \
.filter("created_at", "gte", "2024-01-01") \
.order("created_at", desc=True) \
.limit(10) \
.execute()
# Transactions
async with client.database.transaction() as tx:
await tx.from_("accounts").update({"balance": balance - 100}).eq("id", sender_id)
await tx.from_("accounts").update({"balance": balance + 100}).eq("id", receiver_id)
await tx.from_("transactions").insert({
"from": sender_id, "to": receiver_id, "amount": 100
})
```
### Realtime Subscriptions
```python
def handle_changes(payload):
print(f"Database change: {payload}")
# Subscribe to table changes
subscription = await client.realtime.channel("public:posts") \
.on("INSERT", handle_changes) \
.on("UPDATE", handle_changes) \
.subscribe()
```
### File Upload with Progress
```python
def upload_progress(bytes_uploaded, total_bytes):
progress = (bytes_uploaded / total_bytes) * 100
print(f"Upload progress: {progress:.1f}%")
# Upload with progress tracking
await client.storage.bucket("avatars").upload(
"user123.jpg",
file_data,
options={"progress_callback": upload_progress}
)
```
## 🏗️ Architecture
This library provides Python bindings for our high-performance Rust Supabase client:
```
┌─────────────────┐ ┌──────────────────┐ ┌─────────────────┐
│ Python App │───▶│ PyO3 Bindings │───▶│ Rust Core │
└─────────────────┘ └──────────────────┘ └─────────────────┘
│
▼
┌─────────────────┐
│ Supabase API │
└─────────────────┘
```
**Benefits:**
- **Memory Efficiency**: Rust's zero-cost abstractions
- **Concurrency**: Tokio async runtime for high-performance I/O
- **Safety**: Rust's memory safety guarantees
- **Speed**: Compiled native code performance
## 🔄 Migration from supabase-py
Our API is designed to be familiar to `supabase-py` users:
```python
# supabase-py
from supabase import create_client
client = create_client(url, key)
result = client.table("posts").select("*").execute()
# supabase-lib-rs (similar interface, 10x+ faster)
from supabase_lib_rs import Client
client = Client(url, key)
result = await client.database.from_("posts").select("*").execute()
```
**Key differences:**
- **Async by default**: All operations are async for better performance
- **Type hints**: Full type support for better IDE experience
- **Better error handling**: Detailed error messages with context
## 🛠️ Development
### Prerequisites
- Python 3.8+
- Rust 1.70+
- Maturin for building wheels
### Building from Source
```bash
# Clone repository
git clone https://github.com/nizovtsevnv/supabase-lib-rs.git
cd supabase-lib-rs
# Install maturin
pip install maturin
# Build and install in development mode
maturin develop --features python
# Run tests
python -m pytest python/tests/
```
## 📚 Documentation
- [API Reference](https://github.com/nizovtsevnv/supabase-lib-rs/blob/main/python/API.md)
- [Examples](https://github.com/nizovtsevnv/supabase-lib-rs/tree/main/python/examples)
- [Migration Guide](https://github.com/nizovtsevnv/supabase-lib-rs/blob/main/python/MIGRATION.md)
## 🤝 Contributing
Contributions are welcome! Please see our [Contributing Guide](../CONTRIBUTING.md).
## 📄 License
This project is licensed under the MIT License - see the [LICENSE](../LICENSE) file for details.
## 🙏 Acknowledgments
- [Supabase](https://supabase.com) for the amazing platform
- [PyO3](https://pyo3.rs) for excellent Python-Rust interop
- [Tokio](https://tokio.rs) for async runtime