ORMagic 0.4.0

Simple ORM based on Pydantic and SQLite with minimalistic API

ORMagic - Simple ORM for Python

The main goal of ORMagic is to provide a simple and easy-to-use ORM for Python, that is easy to understand and use, while still providing the necessary features to interact with a database. The library is in the early stages of development, so it is not recommended to use it in production. Is based on the Pydantic model and extends it with the ability ti save, read, update and delete data from a SQLite database.

Installation

pip install ORMagic

Usage

Define a model

To define a model, create a class that inherits from DBModel and define the fields using Pydantic's field types.

from ormagic import DBModel

class User(DBModel):
    name: str
    age: int
    created_at: datetime = datetime.now()

# Create the table in the database
User.create_table()

Save, read, update and delete data

# Save data to the database, this will create a new record or update an existing one if the primary key is already present
user = User(name="John", age=30)
user.save()

# Read data from the database
user = User.get(id=1)
print(user)
>>> User(id=1, name='John', age=30, created_at=datetime.datetime(2021, 10, 10, 12, 0, 0))

# Delete data from the database
user.delete()

# Update data
user = User.get(id=1)
user.age = 31
user.save()

Define foreign keys

To define a foreign key, use other models as fields in the model. By default, the foreign key will be set to CASCADE, but you can change it by setting the on_delete parameter of the pydantic field to one of the following values: CASCADE, SET_NULL, RESTRICT, SET_DEFAULT, NO_ACTION.

from ormagic import DBModel

class User(DBModel):
    name: str

class Post(DBModel):
    title: str
    content: str
    user: User # Define a foreign key with default on_delete=CASCADE

User.create_table()
Post.create_table()

user = User(name="John")
user.save()

Post(title="Hello", content="World", user=user).save()

# You can also save child models with new parent object in one step, this will save the parent object first and then the child object
Post(title="Hello", content="World", user=User(name="Alice")).save()

Define foreign key with custom on_delete

from ormagic import DBModel
from pydantic import Field

class User(DBModel):
    name: str

class Post(DBModel):
    title: str
    content: str
    user: User = Field(default=None, on_delete="SET_NULL") # Define a foreign key with on_delete=SET_NULL
    user: User = Field(on_delete="RESTRICT") # Define a foreign key with on_delete=RESTRICT
    user: User = Field(default=1, on_delete="SET_DEFAULT") # Define a foreign key with on_delete=SET_DEFAULT
    user: User = Field(on_delete="NO_ACTION") # Define a foreign key with on_delete=NO_ACTION
    user: User = Field(on_delete="CASCADE") # Define a foreign key with on_delete=CASCADE

User.create_table()
Post.create_table()

Unique constraints

To define a unique constraint, use the unique parameter set to True in the Pydantic field.

from ormagic import DBModel
from pydantic import Field

class User(DBModel):
    name: str
    email: str = Field(unique=True)

You can also use the unique parameter to define one to one relationships between tables.

from ormagic import DBModel
from pydantic import Field

class User(DBModel):
    name: str

class UserProfile(DBModel):
    user: User = Field(unique=True)
    bio: str

Deleting and updating tables

To delete a table, use the drop_table method.

User.drop_table()

To update a table, use the update_table method. (Not implemented yet)

User.update_table()

Features and Roadmap

• Define table schema using Pydantic models
• Basic CRUD operations
  • Save data to the database
  • Read data from the database
  • Update data in the database
  • Delete data from the database
• Relationships between tables
  • One-to-many
    • Create a tables with a foreign key
    • Save data with a foreign key
    • Read data with a foreign key
    • Update data with a foreign key
    • Delete data with a foreign key
      • Cascade
      • Set null
      • Restrict
      • Set default
      • No action
  • One-to-one
  • Many-to-many
• Unique constraints
• Remove table
• Update table schema
• Filter data and retrieve multiple records
• Custom primary key
• Bulk operations (save, update, delete)
• Migrations

License

This project is licensed under the terms of the MIT license

Contributing

Contributions are welcome! Feel free to open an issue or submit a pull request.

Why?

There are many ORMs for Python, but most of them are too complex or have too many features that are not needed for simple projects.