Py Pglite

https://github.com/wey-gu/py-pglite
Admin
Py Pglite is a Python testing library that provides a Pythonic interface for PGlite, offering an...
Tokens:56,467
Snippets:766
Trust Score:10
License:Apache-2.0
Update:3 months ago
Show doc for...
Tokens:
Raw
### Add and Test Examples/Demos

Source: https://github.com/wey-gu/py-pglite/blob/main/CONTRIBUTING.md

Guide for adding new example files, testing individual examples, and running the quickstart demo.

```bash
# Add example
vim examples/testing-patterns/new_example.py
```

```bash
# Test example
uv run pytest examples/testing-patterns/new_example.py -v
```

```bash
# Test quickstart
uv run python examples/quickstart/demo_instant.py
```

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

### Quick Start: Clone, Setup, and Run Development Workflow

Source: https://github.com/wey-gu/py-pglite/blob/main/CONTRIBUTING.md

Clone the repository, install dependencies using uv, set up pre-commit hooks, and run the full development workflow.

```bash
git clone https://github.com/wey-gu/py-pglite.git
cd py-pglite

uv sync

pre-commit install

make dev

source .venv/bin/activate
```

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

### Example Usage of Setup Environment Action in a Workflow

Source: https://github.com/wey-gu/py-pglite/blob/main/CONTRIBUTING.md

Demonstrates how to use the 'Setup Environment' GitHub Action within a job, specifying Python version and enabling test execution.

```yaml
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup Environment
        uses: ./.github/actions/setup-environment
        with:
          python-version: '3.12'
          run-tests: true

      # Additional steps...
```

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

### start

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/api-reference/pglite-manager.md

Starts the PGlite server. This method handles the creation of necessary directories, installation of dependencies, and spawning of the Node.js process for the PGlite socket server.

```APIDOC
## start

### Description
Start the PGlite server.

### Signature
```python
def start(self) -> None
```

### Raises
- `RuntimeError` if server fails to start within timeout

### Side Effects
- Creates work directory with package.json and pglite_manager.js
- Installs npm dependencies if needed
- Spawns Node.js process running PGlite socket server
- Waits for socket/port to become available
```

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

### Run Instant PostgreSQL Demo

Source: https://github.com/wey-gu/py-pglite/blob/main/examples/README.md

Execute the quickstart demo script to see py-pglite in action. This script starts PostgreSQL instantly with zero configuration.

```bash
python quickstart/demo_instant.py
```

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

### Install py-pglite (All Features)

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/quick-reference.md

Install py-pglite with all available features.

```bash
pip install py-pglite[all]
```

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

### Install AsyncpgClient

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/api-reference/database-clients.md

Install the AsyncpgClient directly or with py-pglite integration.

```bash
pip install asyncpg
```

```bash
pip install py-pglite[asyncpg]
```

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

### Install PsycopgClient

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/api-reference/database-clients.md

Install the PsycopgClient with binary support or with py-pglite integration.

```bash
pip install psycopg[binary]
```

```bash
pip install py-pglite[psycopg]
```

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

### Instant PostgreSQL Setup with PGliteManager

Source: https://github.com/wey-gu/py-pglite/blob/main/examples/README.md

Demonstrates the one-line setup for a real PostgreSQL database using PGliteManager, making a full PostgreSQL engine available immediately for use.

```python
# ONE LINE setup - real PostgreSQL ready!
with PGliteManager() as db:
    engine = db.get_engine()
    # Full PostgreSQL power available immediately
```

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

### Install py-pglite with Framework Support

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/README.md

Install py-pglite with optional framework support for SQLAlchemy, Django, or asyncpg.

```bash
pip install py-pglite[sqlalchemy]      # SQLAlchemy + SQLModel
```

```bash
pip install py-pglite[django]          # Django + pytest-django
```

```bash
pip install py-pglite[asyncpg]         # Async PostgreSQL
```

```bash
pip install py-pglite[all]             # Everything
```

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

### Install py-pglite with asyncpg

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/quick-reference.md

Install py-pglite with asyncpg support.

```bash
pip install py-pglite[asyncpg]
```

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

### Asynchronous SQLAlchemy Usage

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/api-reference/sqlalchemy-manager.md

Example of using SQLAlchemyAsyncPGliteManager with an asynchronous SQLAlchemy setup, including model definition, table creation, async session management, and data insertion.

```python
import asyncio
from py_pglite.sqlalchemy import SQLAlchemyAsyncPGliteManager
from sqlalchemy import Column, Integer, String, select
from sqlalchemy.orm import declarative_base
from sqlalchemy.ext.asyncio import AsyncSession

Base = declarative_base()

class User(Base):
    __tablename__ = "users"
    id = Column(Integer, primary_key=True)
    name = Column(String)

async def test_users_async():
    async with SQLAlchemyAsyncPGliteManager() as manager:
        engine = manager.get_engine()
        
        async with engine.begin() as conn:
            await conn.run_sync(Base.metadata.create_all)
        
        async_session = AsyncSession(engine)
        user = User(name="Bob")
        async_session.add(user)
        await async_session.commit()
        
        result = await async_session.execute(select(User))
        assert len(result.scalars().all()) == 1

asyncio.run(test_users_async())
```

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

### Install py-pglite with SQLAlchemy

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/quick-reference.md

Install py-pglite with SQLAlchemy support.

```bash
pip install py-pglite[sqlalchemy]
```

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

### Installing SQLAlchemy for PGlite

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/api-reference/sqlalchemy-manager.md

Install SQLAlchemy or the py-pglite package with SQLAlchemy support if it's not already present.

```bash
# Fix - install SQLAlchemy
pip install sqlalchemy
# or
pip install py-pglite[sqlalchemy]
```

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

### Initialize AsyncpgClient

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/api-reference/database-clients.md

Instantiate the AsyncpgClient. Raises ImportError if asyncpg is not installed.

```python
from py_pglite.clients import AsyncpgClient

client = AsyncpgClient()
```

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

### GitHub Actions CI Configuration

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/configuration.md

An example Py-pglite configuration optimized for GitHub Actions CI, featuring a 60-second timeout, INFO logging, cleanup on exit, and automatic dependency installation.

```python
from py_pglite import PGliteConfig

config = PGliteConfig(
    timeout=60,
    log_level="INFO",
    cleanup_on_exit=True,
    auto_install_deps=True,
)
```

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

### Run Pytest for Real-World Scenarios

Source: https://github.com/wey-gu/py-pglite/blob/main/CONTRIBUTING.md

Validate production usage patterns by running pytest on the examples directory. This ensures that the library functions correctly in common real-world application setups.

```bash
uv run pytest examples/testing-patterns/     # Production usage patterns
```

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

### Pre-commit Hooks: Installation and Execution

Source: https://github.com/wey-gu/py-pglite/blob/main/CONTRIBUTING.md

Install pre-commit hooks to enforce code quality standards and run them across all files.

```bash
pre-commit install
```

```bash
pre-commit run --all-files
```

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

### AsyncpgClient Constructor

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/api-reference/database-clients.md

Initializes the AsyncpgClient. Raises ImportError if asyncpg is not installed.

```APIDOC
## AsyncpgClient()

### Description
Initializes the AsyncpgClient.

### Raises
* `ImportError`: if asyncpg is not installed.

### Example
```python
from py_pglite.clients import AsyncpgClient

client = AsyncpgClient()
```
```

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

### Traditional vs py-pglite Testing

Source: https://github.com/wey-gu/py-pglite/blob/main/README.md

Compares the setup complexity of traditional PostgreSQL testing with the simplicity of py-pglite.

```python
# ❌ Traditional testing
def test_old_way():
    # 1. Install PostgreSQL
    # 2. Configure connection
    # 3. Manage test databases
    # 4. Handle cleanup
    # 5. Docker containers...
    pass

# ✅ py-pglite way
def test_new_way(pglite_session):
    User.objects.create(name="Alice")  # Just works!
```

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

### Install py-pglite Core

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/README.md

Install the core framework-agnostic py-pglite package using pip.

```bash
pip install py-pglite
```

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

### Good vs. Bad: Zero Configuration in Python

Source: https://github.com/wey-gu/py-pglite/blob/main/CONTRIBUTING.md

Illustrates the zero-configuration approach where tables are created automatically, contrasting with manual setup.

```python
# ✅ Good - works immediately
def test_users(pglite_session):
    user = User(name="Alice")
    pglite_session.add(user)
    # Tables created automatically!

```

```python
# ❌ Bad - requires manual setup
def test_users(pglite_session):
    Base.metadata.create_all(pglite_session.bind)  # Manual step

```

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

### Synchronous SQLAlchemy Usage

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/api-reference/sqlalchemy-manager.md

Example of using SQLAlchemyPGliteManager with a synchronous SQLAlchemy setup, including model definition, table creation, session management, and data insertion.

```python
from py_pglite.sqlalchemy import SQLAlchemyPGliteManager
from sqlalchemy import Column, Integer, String, create_engine
from sqlalchemy.orm import declarative_base, sessionmaker

Base = declarative_base()

class User(Base):
    __tablename__ = "users"
    id = Column(Integer, primary_key=True)
    name = Column(String)

def test_users():
    with SQLAlchemyPGliteManager() as manager:
        engine = manager.get_engine()
        Base.metadata.create_all(engine) 
        
        Session = sessionmaker(bind=engine)
        session = Session()
        
        user = User(name="Alice")
        session.add(user)
        session.commit()
        
        assert session.query(User).count() == 1
```

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

### Install py-pglite with Extensions

Source: https://github.com/wey-gu/py-pglite/blob/main/README.md

Install the py-pglite library with the necessary extras for supporting PostgreSQL extensions. This command is used in a shell environment.

```bash
pip install 'py-pglite[extensions]'
```

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

### Starting SQLAlchemy PGlite Manager

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/api-reference/sqlalchemy-manager.md

Ensure the PGlite server is running before obtaining an engine. Use `manager.start()` to initiate the server.

```python
# Wrong - server not started
manager = SQLAlchemyPGliteManager()
engine = manager.get_engine()  # Raises RuntimeError

# Right - start server first
manager = SQLAlchemyPGliteManager()
manager.start()
engine = manager.get_engine()
```

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

### Django Database Configuration for Socket Connection

Source: https://github.com/wey-gu/py-pglite/blob/main/examples/testing-patterns/django/README.md

Example of how to configure Django's `DATABASES` setting to use the standard PostgreSQL backend with a PGlite socket. This setup is part of the lightweight/socket pattern.

```python
# In conftest.py - uses configured_django fixture
DATABASES = {
    "default": {
        "ENGINE": "django.db.backends.postgresql",  # Standard backend
        "HOST": socket_directory,  # PGlite socket
        # ... other settings
    }
}
```

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

### PsycopgClient connect Example

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/api-reference/database-clients.md

Connects to a PostgreSQL database using the PsycopgClient. Requires a valid connection string.

```python
client = PsycopgClient()
conn = client.connect("postgresql://localhost/testdb")
```

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

### Initialize PsycopgClient

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/api-reference/database-clients.md

Initializes the PsycopgClient. Raises ImportError if the psycopg library is not installed.

```python
from py_pglite.clients import PsycopgClient

client = PsycopgClient()
```

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

### Get Default Database Client

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/api-reference/database-clients.md

Retrieves the default database client, preferring psycopg if available and falling back to asyncpg. Raises ImportError if no supported client is installed.

```python
from py_pglite.clients import get_default_client

client = get_default_client()
```

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

### SQLAlchemy Integration Example

Source: https://github.com/wey-gu/py-pglite/blob/main/README.md

Demonstrates how py-pglite works seamlessly with SQLAlchemy for database operations without extra imports.

```python
def test_sqlalchemy_just_works(pglite_session):
    user = User(name="Alice", email="alice@test.com")
    pglite_session.add(user)
    pglite_session.commit()

    assert user.id is not None
    assert User.query.count() == 1  # Real PostgreSQL!
```

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

### Start PGlite Server

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/api-reference/pglite-manager.md

Manually starts the PGlite server. Ensure to call stop() in a finally block to clean up resources.

```python
from py_pglite import PGliteManager

manager = PGliteManager()
manager.start()
try:
    # Use database
    pass
finally:
    manager.stop()
```

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

### Execute Tests and Examples

Source: https://github.com/wey-gu/py-pglite/blob/main/CONTRIBUTING.md

Commands to run all tests, all examples, or specific test files using pytest. This helps in verifying different aspects of the project.

```bash
make test               # All tests
make examples           # All examples
uv run pytest tests/test_core_manager.py -v    # Specific test
```

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

### Install PGlite with Django Support

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/api-reference/django-integration.md

Install the py-pglite package with the Django extra to include Django, pytest-django, and PGlite core.

```bash
pip install py-pglite[django]
```

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

### Local Development Configuration

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/configuration.md

A complete Py-pglite configuration example for local development, enabling DEBUG logging, a 30-second timeout, and cleanup on exit.

```python
from py_pglite import PGliteConfig

config = PGliteConfig(
    log_level="DEBUG",
    timeout=30,
    cleanup_on_exit=True,
)
```

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

### Basic PGliteManager Usage

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/api-reference/pglite-manager.md

Demonstrates basic usage of PGliteManager with automatic start and stop using a context manager. Obtain the DSN for client connections.

```python
from py_pglite import PGliteManager

# Automatic start and stop
with PGliteManager() as manager:
    dsn = manager.get_dsn()
    # Use with psycopg or any client
```

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

### Type Hinting for get_connection_string

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/README.md

Example of a Python type hint for a method returning a string.

```python
def get_connection_string(self) -> str
```

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

### Verify Database Setup and Connection

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/api-reference/utility-functions.md

Performs a comprehensive verification of a pglite database setup. It checks the connection, retrieves the database version, and lists table names if a specific table exists.

```python
from py_pglite import PGliteManager
from py_pglite.utils import (
    check_connection,
    get_database_version,
    get_table_names,
    table_exists
)

def verify_database():
    with PGliteManager() as manager:
        dsn = manager.get_dsn()
        
        # Check connection
        if not check_connection(dsn):
            print("Connection failed!")
            return False
        
        # Get version
        version = get_database_version(dsn)
        print(f"Version: {version}")
        
        # Check for specific table
        if table_exists(dsn, "users"):
            # Get all tables
            tables = get_table_names(dsn)
            print(f"All tables: {tables}")
        
        return True

verify_database()
```

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

### Development Commands: Core Workflow

Source: https://github.com/wey-gu/py-pglite/blob/main/CONTRIBUTING.md

Execute core development tasks including linting, testing, and running examples.

```bash
make dev         # Full workflow (linting + tests + examples)
make test        # Run tests only
make examples    # Run examples only
make lint        # Run linting only
make quick       # Quick checks during development
```

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

### Type Hinting for wait_for_ready

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/README.md

Example of Python type hints for a method with an integer parameter and boolean return.

```python
def wait_for_ready(self, max_retries: int = 15) -> bool
```

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

### Register PostgreSQL Extension

Source: https://github.com/wey-gu/py-pglite/blob/main/CONTRIBUTING.md

Example of how to register a new PostgreSQL extension by updating the SUPPORTED_EXTENSIONS dictionary in py_pglite/extensions.py.

```python
# py_pglite/extensions.py
SUPPORTED_EXTENSIONS = {
    "pgvector": {"module": "@electric-sql/pglite/vector", "name": "vector"},
    "new_extension": {"module": "npm-package-name", "name": "js_export_name"},
}
```

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

### Development Commands: Utility Functions

Source: https://github.com/wey-gu/py-pglite/blob/main/CONTRIBUTING.md

Perform utility operations such as installation, cleaning build artifacts, formatting, and checking project status.

```bash
make install     # Install in development mode
make clean       # Clean build artifacts
make fmt         # Auto-fix formatting
make status      # Show project status
```

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

### py-pglite Way for Simplified Testing

Source: https://github.com/wey-gu/py-pglite/blob/main/examples/README.md

Shows the ease of use with py-pglite, where database operations work directly without extensive setup.

```python
def test_my_feature(pglite_session):
    User.objects.create(name="Alice")  # Just works!
```

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

### PsycopgClient test_connection Example

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/api-reference/database-clients.md

Tests the connection to a PostgreSQL database using the PsycopgClient. Returns a boolean indicating success.

```python
client = PsycopgClient()
is_ready = client.test_connection("postgresql://localhost/testdb")
```

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

### Get All Django Models

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/api-reference/django-integration.md

Fetches a list of all Django model classes from the installed applications. Raises ImportError if Django is not installed.

```python
from py_pglite.django import get_django_models

models = get_django_models()
for model in models:
    print(f"{model.__name__}: {model._meta.db_table}")
```

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

### Start PGlite Manager and Get DSN

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/quick-reference.md

If you encounter the 'PGlite server is not running' error, start the manager and retrieve the Data Source Name (DSN).

```python
# Fix: Start the manager
manager.start()
ds = manager.get_dsn()
```

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

### Traditional Way of Setting Up PostgreSQL for Testing

Source: https://github.com/wey-gu/py-pglite/blob/main/examples/README.md

Illustrates the manual steps and complexities involved in setting up PostgreSQL for traditional testing environments.

```python
# 1. Install PostgreSQL server
# 2. Configure connection strings
# 3. Manage test databases
# 4. Handle cleanup manually
# 5. Docker containers...
# 6. Still not portable
```

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

### Get Default Client

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/quick-reference.md

Obtain the default client, which will be either PsycopgClient or AsyncpgClient based on availability.

```python
from py_pglite.clients import get_default_client

client = get_default_client()  # PsycopgClient or AsyncpgClient
```

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

### Create Django Superuser

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/quick-reference.md

Create a Django superuser with the specified username and password. Useful for initial setup.

```python
from py_pglite.django import create_django_superuser

user = create_django_superuser(
    username="admin",
    password="secure123"
)
```

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

### Get Py-pglite Version

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/modules-overview.md

Import the py-pglite library and print the __version__ attribute to retrieve the current installed version.

```python
import py_pglite

print(py_pglite.__version__)
```

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

### Django Lightweight/Socket Testing Pattern

Source: https://github.com/wey-gu/py-pglite/blob/main/README.md

Uses the lightweight socket pattern for minimal Django setup with py-pglite.

```python
def test_django_socket_pattern(configured_django):
    Post.objects.create(title="Hello", content="World")
    assert Post.objects.count() == 1  # Real PostgreSQL via socket!
```

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

### Async Test Fixture for PGlite

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/quick-reference.md

Example of using an async test fixture with PGlite for asynchronous testing scenarios. Assumes pytest-asyncio is installed.

```python
@pytest.mark.asyncio
async def test_async(pglite_async_session):
    # Use async session
    await session.commit()
```

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

### FastAPI Integration with PGlite

Source: https://github.com/wey-gu/py-pglite/blob/main/examples/README.md

Provides an example of integrating PGlite with FastAPI to create a user endpoint, demonstrating a real PostgreSQL backend for API operations.

```python
# FastAPI integration
@app.post("/users/")
def create_user(user: UserCreate, session: Session = Depends(get_db)):
    db_user = User(**user.dict())
    session.add(db_user)
    session.commit()
    return db_user  # Real PostgreSQL backend!
```

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

### Get Django Connection Parameters

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/api-reference/django-integration.md

Retrieves a dictionary of database connection parameters formatted for Django, based on a PGliteManager instance. Requires PGliteManager to be started.

```python
from py_pglite import PGliteManager
from py_pglite.django import get_django_connection_params

manager = PGliteManager()
manager.start()

params = get_django_connection_params(manager)
# {
#     'ENGINE': 'py_pglite.django.backend',
#     'NAME': 'postgres',
#     'USER': 'postgres',
#     'PASSWORD': 'postgres',
#     'HOST': '/tmp/...',
#     'PORT': '',
#     'OPTIONS': {'host': '/tmp/...'},
#     'TEST': {'NAME': 'test_pglite_db'}
# }
```

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

### Py-pglite Project Structure Overview

Source: https://github.com/wey-gu/py-pglite/blob/main/CONTRIBUTING.md

This tree displays the directory structure of the py-pglite project, highlighting the core package, tests, examples, and the Makefile for convenience commands.

```bash
py-pglite/
├── py_pglite/                    # 📦 Core package
│   ├── __init__.py              #    Public API
│   ├── manager.py               #    Framework-agnostic PGlite management
│   ├── config.py                #    Robust configuration system
│   ├── utils.py                 #    Framework-agnostic utilities
│   ├── sqlalchemy/              #    SQLAlchemy integration
│   │   ├── manager.py           #    Enhanced SQLAlchemy manager
│   │   ├── fixtures.py          #    Pytest fixtures
│   │   └── utils.py             #    SQLAlchemy utilities
│   ├── django/                  #    Django integration
│   │   ├── fixtures.py          #    Django fixtures
│   │   └── utils.py             #    Django utilities
│   ├── pytest_plugin.py         #    Auto-discovery pytest plugin
│   └── extensions.py            #    🆕 Extension registry (e.g., pgvector)
│
├── tests/                       # 🧪 Core tests (88 tests)
│   ├── test_core_manager.py     #    Manager lifecycle & process management
│   ├── test_advanced.py         #    Advanced usage patterns
│   ├── test_configuration.py    #    🆕 Configuration validation & edge cases
│   ├── test_connection_management.py # 🆕 Connection pooling & lifecycle
│   ├── test_reliability.py      #    🆕 Error recovery & resilience
│   ├── test_django_backend.py   #    🆕 Django backend & decoupling
│   ├── test_fastapi_integration.py #  FastAPI patterns
│   ├── test_framework_isolation.py # Framework isolation validation
│   └── test_extensions.py       #    🆕 Extension tests (e.g., pgvector)
│
├── examples/                    # 📚 Examples & demos (51 tests)
│   ├── quickstart/              #    ⚡ Instant demos
│   │   ├── demo_instant.py      #    5-line PostgreSQL demo
│   │   ├── simple_fastapi.py    #    FastAPI integration
│   │   └── simple_performance.py #   Performance comparison
│   ├── features/                #    🆕 Advanced feature examples
│   │   └── test_pgvector_rag.py #    pgvector RAG example
│   └── testing-patterns/        #    🧪 Production examples
│       ├── sqlalchemy/          #    SQLAlchemy patterns (2 tests)
│       ├── django/              #    Django patterns (10 tests)
│       └── test_fixtures_showcase.py # Advanced patterns (8 tests)
└── Makefile                     # 🎯 Convenience commands
```

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

### Get Specific Database Client

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/api-reference/database-clients.md

Obtains a database client by specifying the client type. Raises ImportError if the specified client is not installed or ValueError if the client_type is unknown.

```python
from py_pglite.clients import get_client

# Auto-detect best available client
client = get_client()

# Explicitly request psycopg
client = get_client("psycopg")

# Explicitly request asyncpg
client = get_client("asyncpg")
```

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

### Setup Environment GitHub Action

Source: https://github.com/wey-gu/py-pglite/blob/main/CONTRIBUTING.md

Configuration for the reusable GitHub Action to set up Python, Node.js, and uv environments. It supports specifying versions and enabling tests and coverage.

```yaml
- name: Setup Environment
  uses: ./.github/actions/setup-environment
  with:
    python-version: '3.11'  # Default, can be configured
    node-version: '22'      # Default, can be configured
    run-tests: true         # Optional, runs pytest
    coverage: true          # Optional, generates coverage report
```

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

### Run All Django Tests

Source: https://github.com/wey-gu/py-pglite/blob/main/examples/testing-patterns/django/README.md

Execute all available Django tests within the Py-pglite examples directory. This command runs tests for both lightweight and full integration patterns.

```bash
pytest examples/testing-patterns/django/ -v
```

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

### Basic Query Execution with PsycopgClient

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/api-reference/database-clients.md

Demonstrates basic query execution using PsycopgClient, including connecting to a database, executing a query with parameters, and closing the connection.

```python
from py_pglite.clients import PsycopgClient

client = PsycopgClient()
conn = client.connect("postgresql://localhost/testdb")

results = client.execute_query(
    conn,
    "SELECT * FROM users WHERE id = %s",
    (1,)
)

client.close_connection(conn)
```

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

### Manual PGliteManager Lifecycle

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/api-reference/pglite-manager.md

Illustrates manual control over the PGliteManager lifecycle, including starting, waiting for readiness, and stopping the process. Ensure cleanup with a try-finally block.

```python
from py_pglite import PGliteManager

manager = PGliteManager()
try:
    manager.start()
    manager.wait_for_ready()
    
    # Use database
    dsn = manager.get_dsn()
    
finally:
    manager.stop()
```

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

### Run FastAPI Integration Demo

Source: https://github.com/wey-gu/py-pglite/blob/main/examples/README.md

Execute the simple FastAPI integration script. This demonstrates building a production-ready REST API with PostgreSQL in a minimal number of lines.

```bash
python quickstart/simple_fastapi.py
# Open http://localhost:8000/docs
```

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

### Wait for PGlite Database Readiness

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/api-reference/sqlalchemy-manager.md

Asynchronously wait for the PGlite database to become ready and responsive. This is crucial before attempting to get the engine or perform database operations. Ensure SQLAlchemy is installed.

```python
async with SQLAlchemyAsyncPGliteManager() as manager:
    if await manager.wait_for_ready():
        engine = manager.get_engine()
```

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

### Get SQLAlchemy Async Engine

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/api-reference/sqlalchemy-manager.md

Retrieve the shared SQLAlchemy async engine instance connected to PGlite. This method is useful for performing database operations using SQLAlchemy's async capabilities. Ensure SQLAlchemy is installed.

```python
from py_pglite.sqlalchemy import SQLAlchemyAsyncPGliteManager
from sqlalchemy import text
import asyncio

async def main():
    async with SQLAlchemyAsyncPGliteManager() as manager:
        engine = manager.get_engine()
        
        async with engine.connect() as conn:
            result = await conn.execute(text("SELECT 1"))
            print(result.fetchone()[0])  # 1

asyncio.run(main())
```

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

### SQLModel Usage

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/api-reference/sqlalchemy-manager.md

Example of integrating py-pglite with SQLModel for data modeling and database operations, including table creation, session management, and data insertion.

```python
from py_pglite.sqlalchemy import SQLAlchemyPGliteManager
from sqlmodel import SQLModel, Session, create_engine, select

class User(SQLModel, table=True):
    id: int | None = None
    name: str

def test_sqlmodel():
    with SQLAlchemyPGliteManager() as manager:
        engine = manager.get_engine()
        SQLModel.metadata.create_all(engine)
        
        with Session(engine) as session:
            user = User(name="Charlie")
            session.add(user)
            session.commit()
            
            result = session.exec(select(User))
            assert len(result.all()) == 1
```

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

### Package Manager: uv Usage in Make Commands

Source: https://github.com/wey-gu/py-pglite/blob/main/CONTRIBUTING.md

Demonstrates how 'make' commands leverage 'uv' for package management and development tasks.

```bash
make install     # Uses uv sync
make dev         # Uses uv run pytest
make lint        # Uses uv run pre-commit
```

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

### Get SQLAlchemy Engine

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/api-reference/sqlalchemy-manager.md

Retrieves a SQLAlchemy engine connected to PGlite. It returns a shared engine instance to prevent connection timeouts, as PGlite's socket server can only handle one connection at a time. Ensure SQLAlchemy is installed.

```python
def get_engine(
    self, 
    driver: Literal["psycopg", "psycopg2"] = "psycopg", 
    **engine_kwargs: Any
) -> Any
```

```python
from py_pglite.sqlalchemy import SQLAlchemyPGliteManager
from sqlalchemy import create_engine, text

with SQLAlchemyPGliteManager() as manager:
    engine = manager.get_engine()
    
    with engine.connect() as conn:
        result = conn.execute(text("SELECT 1"))
        print(result.fetchone()[0])  # 1
```

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

### Basic Usage (Framework-Agnostic)

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/quick-reference.md

Use PGliteManager as a context manager to obtain a DSN for any PostgreSQL client.

```python
from py_pglite import PGliteManager

# Context manager (recommended)
with PGliteManager() as manager:
    dsn = manager.get_dsn()
    # Use with any PostgreSQL client
```

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

### Django + Pytest Example

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/README.md

An example of using the django_pglite_db fixture in a pytest test case for Django models.

```python
def test_models(django_pglite_db):
    from django.contrib.auth.models import User
    
    user = User.objects.create_user("alice")
    assert User.objects.count() == 1
```

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

### Run Pattern Comparison Tests

Source: https://github.com/wey-gu/py-pglite/blob/main/examples/testing-patterns/django/README.md

Execute tests that compare both lightweight/socket and full integration patterns side-by-side. This is useful for direct comparison and migration analysis.

```bash
pytest examples/testing-patterns/django/comparison/ -v -s
```

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

### Handle Missing SQLAlchemy Dependency

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/quick-reference.md

Catch an ImportError if SQLAlchemy is not installed and prompt the user to install it using pip.

```python
# SQLAlchemy not installed
from py_pglite import PGliteConfig
config = PGliteConfig()

try:
    manager = SQLAlchemyPGliteManager(config)
except ImportError:
    print("Install: pip install sqlalchemy")
```

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

### Connection String Formats

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/types.md

Illustrates different formats for connection strings, including SQLAlchemy, DSN (psycopg), and URI (asyncpg, psycopg).

```sql
# Connection string format (SQLAlchemy)
connection_string: str
# Example: "postgresql+psycopg://postgres:postgres@/postgres?host=/tmp/..."

# DSN format (psycopg)
dsn: str
# Example: "host=/tmp/... dbname=postgres user=postgres password=postgres"

# URI format (asyncpg, psycopg)
uri: str
# Example: "postgresql://postgres:postgres@/postgres?host=/tmp/..."
```

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

### Run Quick Development Loop Commands

Source: https://github.com/wey-gu/py-pglite/blob/main/CONTRIBUTING.md

Use these commands for making changes and performing quick validations during development. `make quick` is for linting and import checks, while `make dev` runs the full validation suite similar to CI.

```bash
# Make your changes
vim py_pglite/manager.py

# Quick validation
make quick              # ~10s: linting + imports

# Full validation
make dev                # ~30s: everything (like CI)
```

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

### Set Short Startup Timeout

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/configuration.md

Sets a shorter startup timeout of 10 seconds for Py-pglite, suitable for fast local development environments.

```python
# For fast local development
config = PGliteConfig(timeout=10)  # 10 seconds
```

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

### Test Querying Models

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/quick-reference.md

Shows how to add a model, commit it, and then query the total count of instances for that model.

```python
def test_query(pglite_session):
    pglite_session.add(User(name="Bob"))
    pglite_session.commit()
    
    count = pglite_session.query(User).count()
    assert count == 1
```

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

### Node.js Configuration for PGlite

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/configuration.md

Configures PGlite with custom Node.js options, such as increasing memory allocation, and disables automatic dependency installation. This is useful if dependencies are already installed.

```python
from py_pglite import PGliteConfig

config = PGliteConfig(
    node_options="--max-old-space-size=4096",
    auto_install_deps=False,
)
# Disable auto npm install if already done
# Add custom Node.js options for memory/performance
```

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

### Control npm Dependency Installation

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/configuration.md

Manage automatic npm dependency installation and node_modules checking. Set `auto_install_deps` to `False` and `node_modules_check` to `False` for faster startup if dependencies are pre-installed.

```python
# Auto-install dependencies (default)
config = PGliteConfig(auto_install_deps=True)
```

```python
# Skip auto-install (already installed)
config = PGliteConfig(auto_install_deps=False)
```

```python
# Force check for node_modules (default)
config = PGliteConfig(node_modules_check=True)
```

```python
# Skip node_modules check (faster startup)
config = PGliteConfig(node_modules_check=False, auto_install_deps=False)
```

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

### Use Custom Database Client

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/api-reference/utility-functions.md

Demonstrates how to use a custom client, such as PsycopgClient, with PGliteManager for database interactions. Ensures compatibility and allows for specific client features.

```python
from py_pglite import PGliteManager
from py_pglite.clients import PsycopgClient
from py_pglite.utils import check_connection

def test_with_psycopg():
    client = PsycopgClient()
    
    with PGliteManager() as manager:
        dsn = manager.get_dsn()
        
        # Use specific client
        if check_connection(dsn, client=client):
            print("PsycopgClient works!")

test_with_psycopg()
```

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

### Configure Django for PGlite

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/api-reference/django-integration.md

Sets up Django's settings to utilize PGlite as the database backend. Pass additional Django settings as keyword arguments. Raises ImportError if Django is not installed.

```python
from py_pglite.django import configure_django_for_pglite

configure_django_for_pglite(
    DEBUG=False,
    ALLOWED_HOSTS=["*"],
)
```

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

### get_client

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/api-reference/database-clients.md

Get a database client by specifying the client type.

```APIDOC
## get_client

### Description
Get a database client by type.

### Parameters
#### Query Parameters
- **client_type** (str) - Optional - "auto" - Client type: "psycopg", "asyncpg", or "auto"

### Returns
DatabaseClient instance

### Raises
- `ImportError` if specified client is not installed
- `ValueError` if client_type is unknown

### Example
```python
from py_pglite.clients import get_client

# Auto-detect best available client
client = get_client()

# Explicitly request psycopg
client = get_client("psycopg")

# Explicitly request asyncpg
client = get_client("asyncpg")
```
```

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

### Execute Raw SQL with PsycopgClient

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/quick-reference.md

Demonstrates executing a raw SQL query using the PsycopgClient and a DSN obtained from the PGlite manager.

```python
def test_raw_sql(pglite_manager):
    dsn = pglite_manager.get_dsn()
    
    # Use any client
    from py_pglite.clients import PsycopgClient
    
    client = PsycopgClient()
    conn = client.connect(dsn)
    result = client.execute_query(conn, "SELECT 1")
    client.close_connection(conn)
```

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

### get_django_models

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/api-reference/django-integration.md

Retrieves a list of all Django model classes available from the installed applications.

```APIDOC
## get_django_models

### Description
Get all Django models from installed apps.

### Returns
List of Django model classes

### Raises
- ImportError: if Django is not installed

### Example
```python
from py_pglite.django import get_django_models

models = get_django_models()
for model in models:
    print(f"{model.__name__}: {model._meta.db_table}")
```
```

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

### Configure PGlite for Production

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/api-reference/pglite-config.md

Set up a production-ready configuration with options like timeout, log level, cleanup behavior, working directory, and automatic dependency installation. This configuration prioritizes stability and manageability.

```python
from pathlib import Path
from py_pglite import PGliteConfig, PGliteManager

config = PGliteConfig(
    timeout=60,
    log_level="WARNING",
    cleanup_on_exit=True,
    work_dir=Path("./pglite-data"),
    auto_install_deps=True
)

with PGliteManager(config) as db:
    pass
```

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

### PsycopgClient close_connection Example

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/api-reference/database-clients.md

Closes an active PostgreSQL connection managed by the PsycopgClient.

```python
client.close_connection(conn)
```

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

### SQLAlchemy Integration with PGlite

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/README.md

Shows how to use SQLAlchemyPGliteManager to get a SQLAlchemy engine.

```python
from py_pglite.sqlalchemy import SQLAlchemyPGliteManager

with SQLAlchemyPGliteManager() as db:
    engine = db.get_engine()
```

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

### Run Pre-commit Hooks with Make

Source: https://github.com/wey-gu/py-pglite/blob/main/CONTRIBUTING.md

Execute all pre-commit hooks manually using the 'make lint' command. For formatting only, use 'make fmt'.

```bash
make lint               # Uses uv run pre-commit run --all-files
```

```bash
make fmt                # Uses uv run ruff format
```

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

### Good vs. Bad: Optional Dependencies in Python

Source: https://github.com/wey-gu/py-pglite/blob/main/CONTRIBUTING.md

Shows how to handle optional dependencies gracefully using a try-except block for graceful degradation.

```python
# ✅ Good - graceful degradation
try:
    from sqlalchemy import Engine
except ImportError:
    Engine = None  # type: ignore

```

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

### Get Database Version

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/quick-reference.md

Retrieve the PostgreSQL version of the database. Requires a DSN string.

```python
from py_pglite.utils import get_database_version

version = get_database_version(dsn)
print(f"PostgreSQL {version}")
```

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

### Django Integration

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/quick-reference.md

Example of using Django models with py-pglite, assuming django_pglite_db fixture is available.

```python
def test_django_models(django_pglite_db):
    from django.contrib.auth.models import User
    
    user = User.objects.create_user("alice")
    assert User.objects.count() == 1
```

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

### Connect to PostgreSQL

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/api-reference/database-clients.md

Create an asyncpg connection using a synchronous wrapper. Requires a PostgreSQL connection string.

```python
client = AsyncpgClient()
conn = client.connect("postgresql://localhost/testdb")
```

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

### Good vs. Bad: Framework Agnostic Core in Python

Source: https://github.com/wey-gu/py-pglite/blob/main/CONTRIBUTING.md

Demonstrates the preferred way to import core functionalities without framework-specific dependencies.

```python
# ✅ Good - no framework dependencies
from py_pglite import PGliteManager

```

```python
# ❌ Bad - framework-specific in core
from py_pglite.sqlalchemy import SomeHelper

```

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

### Get PostgreSQL Database Version

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/api-reference/database-clients.md

Retrieves the PostgreSQL database version for a given connection string.

```python
from py_pglite.clients import get_client

client = get_client("psycopg")
version = client.get_database_version("postgresql://localhost/testdb")
print(f"PostgreSQL version: {version}")
```

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

### Custom QueuePool Configuration

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/api-reference/sqlalchemy-manager.md

Demonstrates configuring a custom QueuePool with specific size and overflow settings. Be mindful of PGlite's socket limitations.

```python
from sqlalchemy.pool import QueuePool

manager = SQLAlchemyPGliteManager()
engine = manager.get_engine(
    poolclass=QueuePool,
    pool_size=5,
    max_overflow=10,
    pool_timeout=30
)
```

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

### Basic PGliteManager Usage

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/README.md

Demonstrates basic usage of PGliteManager to obtain a DSN for PostgreSQL clients.

```python
from py_pglite import PGliteManager

with PGliteManager() as db:
    dsn = db.get_dsn()
    # Use with any PostgreSQL client
```

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

### Add Test for New Extension

Source: https://github.com/wey-gu/py-pglite/blob/main/CONTRIBUTING.md

Example of creating a new test file for an extension, using the '@pytest.mark.extensions' marker.

```python
# tests/test_new_extension.py
import pytest

@pytest.mark.extensions
def test_new_extension_feature():
    # ...

```

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

### Efficient Multiple Queries with Connection Pooling

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/api-reference/utility-functions.md

Illustrates an efficient way to execute multiple queries by obtaining a client, establishing a single connection, performing queries, and then closing the connection. This minimizes connection overhead for batch operations.

```Python
from py_pglite.clients import get_default_client

client = get_default_client()
conn = client.connect(dsn)

try:
    # Multiple queries on same connection
    results1 = client.execute_query(conn, "SELECT COUNT(*) FROM users")
    results2 = client.execute_query(conn, "SELECT COUNT(*) FROM posts")
finally:
    client.close_connection(conn)
```

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

### Set Django Admin Password Environment Variable

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/configuration.md

Example of setting the DJANGO_ADMIN_PASSWORD environment variable before running pytest.

```bash
export DJANGO_ADMIN_PASSWORD="secure123"
pytest tests/
```

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

### PsycopgClient get_database_version Example

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/api-reference/database-clients.md

Retrieves the PostgreSQL version string using the PsycopgClient. Returns None if the operation fails.

```python
client = PsycopgClient()
version = client.get_database_version(dsn)
# "PostgreSQL 17.0 on ..."
```

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

### Run Performance Comparison Demo

Source: https://github.com/wey-gu/py-pglite/blob/main/examples/README.md

Execute the performance comparison script. This script provides honest results comparing py-pglite with SQLite and Docker PostgreSQL.

```bash
python quickstart/simple_performance.py
```

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

### Get Psycopg URI for TCP Connection

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/quick-reference.md

Generate a psycopg-compatible URI for connecting to PGlite when TCP mode is enabled.

```python
config = PGliteConfig(use_tcp=True)
uri = config.get_psycopg_uri()
# postgresql://postgres:postgres@127.0.0.1:5432/postgres
```

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

### Abstract connect Method

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/api-reference/database-clients.md

Abstract method signature for creating a database connection. Requires a connection string.

```python
@abstractmethod
def connect(self, connection_string: str) -> Any
```

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

### Get SQLAlchemy Connection String

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/api-reference/pglite-config.md

Retrieves a PostgreSQL connection string suitable for SQLAlchemy. Defaults to the 'psycopg' driver.

```python
from py_pglite import PGliteConfig\nfrom sqlalchemy import create_engine\n\nconfig = PGliteConfig()\nconnection_string = config.get_connection_string()\nengine = create_engine(connection_string)
```

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

### Connect with asyncpg using TCP

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/quick-reference.md

Generate an asyncpg-compatible URI for TCP connections and establish a connection.

```python
config = PGliteConfig(use_tcp=True)
uri = config.get_asyncpg_uri()

import asyncpg
conn = await asyncpg.connect(uri, server_settings={})
```

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

### Development PGlite Configuration

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/configuration.md

Configures PGlite for development with a 30-second timeout, DEBUG log level, and automatic dependency installation.

```python
from py_pglite import PGliteConfig

config = PGliteConfig(
    timeout=30,
    log_level="DEBUG",
    auto_install_deps=True,
)
```

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

### Conditional Django Import

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/modules-overview.md

Imports Django configuration utilities if Django is installed. This enables optional integration with Django projects.

```python
try:
    from py_pglite.django import configure_django_for_pglite
except ImportError:
    pass  # Django not installed
```

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

### Testing with Extensions Configuration

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/configuration.md

Demonstrates Py-pglite configuration for testing scenarios that require specific extensions like 'pgvector' and 'pg_trgm', with WARNING logging and a 45-second timeout.

```python
from py_pglite import PGliteConfig

config = PGliteConfig(
    timeout=45,
    extensions=["pgvector", "pg_trgm"],
    log_level="WARNING",
)
```

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

### Conditional SQLAlchemy Import

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/modules-overview.md

Imports the SQLAlchemy PGlite manager if SQLAlchemy is installed. This allows for optional integration with SQLAlchemy ORM.

```python
try:
    from py_pglite.sqlalchemy import SQLAlchemyPGliteManager
except ImportError:
    pass  # SQLAlchemy not installed
```

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

### Handle Manager Not Running Error

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/quick-reference.md

Use a try-except block to catch a RuntimeError if the manager is not running, then start it and retrieve the DSN.

```python
from py_pglite import PGliteManager

manager = PGliteManager()
try:
    dsn = manager.get_dsn()  # Raises RuntimeError
except RuntimeError:
    manager.start()
    dsn = manager.get_dsn()
```

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

### Set Startup Timeout (Default)

Source: https://github.com/wey-gu/py-pglite/blob/main/_autodocs/configuration.md

Sets the startup timeout for Py-pglite to 30 seconds, which is the default value. This configuration is suitable for most CI/CD environments.

```python
# 30-second timeout (default)
config = PGliteConfig(timeout=30)
```
Tokens:
Raw