Ormophine

A fast, Pythonic ORM that gets out of your way.

Write database queries the way you think — in plain Python.

The Problem with Other ORMs

Most Python ORMs are either too verbose, too magical, or too slow. Compare fetching filtered rows with a popular ORM versus Ormophine:

Other ORMs:

# SQLAlchemy (Core)
with engine.connect() as conn:
    stmt = select(users.c.phone, users.c.name, users.c.age).where(
        and_(
            users.c.age > 18,
            or_(
                users.c.phone.like('+98%'),
                func.substr(users.c.phone, 1, 3) == '+98'
            )
        )
    ).order_by(users.c.age)
    result = conn.execute(stmt).fetchall()

Ormophine:

my_db = Ormophine.Sqlite('my_db')
users = my_db.users
phone, name, age = users.phone, users.name, users.age

users.get_row(
    [phone, name, age],
    where = (age > 18) & (phone.startswith('+98') | (phone[:3] == '+98')),
    order_by = age
)

Same result. No boilerplate. No imports. No ceremony.

Why Ormophine?

Intuitive syntax — columns behave like Python variables with full operator overloading (>, &, |, +, [], .startswith(), etc.)
Fast — built on a dedicated writer thread + read-only connection pool; no ORM overhead on the hot path
Multi-database — one API across all supported backends
Connection pooling built-in — parallel reads, serialized writes, no configuration needed
WAL mode support (SQLite) — automatic checkpointing for maximum write throughput
Blocking and non-blocking — fire-and-forget writes or wait for commit confirmation

Supported Databases

Database	Status
SQLite	✅ Available
MySQL	🔧 In development
MariaDB	🔧 In development
PostgreSQL	🔧 In development

The API is identical across all backends. Switch databases by changing one line.

Benchmark Results

📊 Coming soon — benchmark results comparing Ormophine against SQLAlchemy, Tortoise ORM, and raw DB-API 2.0 will be published here across INSERT, SELECT, bulk operations, and concurrent read workloads.

Quick Examples

Connect and access tables

import Ormophine

db = Ormophine.Sqlite('company.db')

# Tables and columns are discovered automatically
users   = db.users
orders  = db.orders

Insert

users.insert({
    users.name:  'Alice',
    users.email: 'alice@example.com',
    users.age:   30
})

Select with conditions

name, email, age = users.name, users.email, users.age

rows = users.get_row(
    [name, email],
    where   = (age >= 18) & name.startswith('A'),
    order_by = age
)

Update

users.update(
    update = {users.age: users.age + 1},
    where  = users.status == 'active'
)

Bulk insert

users.bulk_insert(
    columns   = [users.name, users.age],
    data_list = [['Bob', 25], ['Carol', 32], ['Dave', 28]]
)

Joins

from Ormophine import Join

result = orders.join(
    columns    = [users.name, orders.amount, orders.date],
    joins_list = [Join.Inner(users, users.id == orders.user_id)],
    where      = orders.amount > 100,
    order_by   = [orders.date]
)

Batch operations (single transaction)

(users.batch()
    .insert({users.name: 'Eve', users.age: 28})
    .update({users.age: 29}, where=users.name == 'Eve')
    .run())

Schema management

from Ormophine import TableStructure

schema = TableStructure('products', strict=True)
schema.add_column('id',    int,   primary_key=True)
schema.add_column('title', str,   not_null=True, unique=True)
schema.add_column('price', float, default_value=0.0)

products = db.create_table(schema)

# Add / rename / drop columns
products.add_column('stock', int, default_value=0, not_null=True)
products.rename_column(products.stock, 'inventory')
products.delete_column(products.inventory, True, True, True)

WAL mode and performance tuning

db.set_WAL_mode(True, wal_timer=60)   # automatic checkpoint every 60 s

db.SetPragma.synchronous('NORMAL')
db.SetPragma.cache_size(-4000)        # 4 MiB page cache
db.SetPragma.foreign_keys(True)

Operator Reference

Ormophine columns support native Python expressions — all values are automatically parameterized.

Expression	SQL equivalent
`age > 18`	`age > 18`
`(age >= 18) & (age < 65)`	`age >= 18 AND age < 65`
`status == 'active'`	`status = 'active'`
`name.startswith('A')`	`name LIKE 'A%'`
`email.contains('@corp.com')`	`email LIKE '%@corp.com%'`
`code[:3]`	`SUBSTR(code, 1, 3)`
`name.upper().strip()`	`TRIM(UPPER(name))`
`price * qty - discount`	`price * qty - discount`

Installation

🚧 PyPI release coming soon.

# Not yet available — star the repo to get notified
pip install ormophine

Roadmap

SQLite backend with full ORM
Operator overloading for columns
Read-only connection pool
WAL mode + automatic checkpointing
Batch / bulk operations
MySQL / MariaDB backend
PostgreSQL backend
Async support
PyPI release
Benchmark suite publication

Contributing

The codebase is currently in active development and not yet public. Once released, contributions, bug reports, and feature requests will be very welcome.

License

MIT — free to use, modify, and distribute.

_{Built with Python · Designed for developers who value clarity and speed}

Release files for Ormophine 0.7.1

For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.

Source distribution (sdist)

Source distribution for Ormophine 0.7.1
File	Size	Uploaded
ormophine-0.7.1.tar.gz	273.2 kB	Aug 3, 2026	Details

Built distribution (wheel)

Table of built distributions (wheels) for Ormophine 0.7.1
File	Interpreter	ABI	Platform	Reset
ormophine-0.7.1-py3-none-any.whl 288.1 kB Aug 3, 2026	Python 3	none	any	Details

Total release size: 561.4 kB

Release files / ormophine-0.7.1.tar.gz

Download URL	ormophine-0.7.1.tar.gz
Size	273.2 kB
Tags	Source
SHA-256 checksum How to use checksums	`d8b5c807bf7d4f8a10aa0b817c78b2ac0770c189965743f7097c7f3459df34f4`
BLAKE2b-256 checksum How to use checksums	`82ff1e77332047c268727cb057517d8db729bea1bf17b3d8e0c9327c2ea96798`
Upload date	Aug 3, 2026
Uploaded using Trusted Publishing? What is trusted publishing?	No
Uploaded via	`twine/7.0.0 CPython/3.14.5`

Release files / ormophine-0.7.1-py3-none-any.whl

Download URL	ormophine-0.7.1-py3-none-any.whl
Size	288.1 kB
Tags	Python 3
SHA-256 checksum How to use checksums	`0bc62061c11b775207088c81f1cfd9782de3e68672d0f83416c233877d799a4d`
BLAKE2b-256 checksum How to use checksums	`e6d7d94f1d0f9c2352d6ee8bc75888497af7ee18498994aa44df8fa70670bf39`
Upload date	Aug 3, 2026
Uploaded using Trusted Publishing? What is trusted publishing?	No
Uploaded via	`twine/7.0.0 CPython/3.14.5`