luminadb.models package

Submodules

• luminadb.models.errors module
  • ConstraintError
  • NoDataReturnedError
  • ValidationError
• luminadb.models.helpers module
  • Constraint
    • Constraint.apply()
    • Constraint.column
  • ConstraintEnum
    • ConstraintEnum.CASCADE
    • ConstraintEnum.DEFAULT
    • ConstraintEnum.NOACT
    • ConstraintEnum.RESTRICT
    • ConstraintEnum.SETNULL
  • Foreign
    • Foreign.apply()
    • Foreign.on_delete()
    • Foreign.on_update()
    • Foreign.resolve()
    • Foreign.target
  • Primary
    • Primary.apply()
    • Primary.auto
  • Unique
    • Unique.apply()
  • Validators
    • Validators.validate()
  • hook()
  • initiate_hook()
  • initiate_validators()
  • validate()
• luminadb.models.mixin module
  • BaseModelMixin
  • ChunkableMixin
    • ChunkableMixin.chunk()
    • ChunkableMixin.chunk_callback()
  • ScopeMixin
    • ScopeMixin.active()
• luminadb.models.query_builder module
  • QueryBuilder
    • QueryBuilder.count()
    • QueryBuilder.delete()
    • QueryBuilder.fetch()
    • QueryBuilder.fetch_one()
    • QueryBuilder.limit()
    • QueryBuilder.offset()
    • QueryBuilder.order_by()
    • QueryBuilder.patch()
    • QueryBuilder.throw()
    • QueryBuilder.update()
    • QueryBuilder.where()
  • add_excnote()
• luminadb.models.type_checkers module
  • infer_type()
  • typecheck()

Module contents

Models

class luminadb.models.BaseModel

Bases: object

Base class for all Models using Model API

classmethod all()

Return all values from the table

classmethod atomic()

Perform operations within a transaction.

belongs_to(related_model: Type[T])

Retrieve the related model that this instance belongs to.

classmethod bulk_create(records: list[dict])

Insert multiple records at once.

classmethod bulk_delete(keys: list[Any], key: str)

Delete multiple records using a primary key.

classmethod bulk_update(records: list[dict], key: str | object = <object object>)

Update multiple records using a primary key or provided key.

classmethod count(**kwargs) → int

Return count of matching records.

classmethod create(**kwargs)

Create data based on kwargs

classmethod create_table(db: Database)

Create table according to annotations and schema from __schema__

delete(_BaseModel__primary=<object object>, /)

Delete current data

classmethod exists(**kwargs) → bool

Check if any record matches the query.

classmethod find(amount: int)

Return models relative to the amount

classmethod find_or_fail(amount: int)

Return models relative to the amount and when returned is equal to 0, throws an error

classmethod first(**kwargs)

Return the first matching record or None if no match is found.

classmethod first_or_fail(**kwargs)

Return the first matching record or raise an error if no match is found.

classmethod get_table()

Return table instance

has_many(related: ~typing.Type[~luminadb.models.T], foreign_key: str | object = <object object>)

Ensure related_model has a Foreign key pointing to self

has_one(related_model: Type[T])

Retrieve the related model where this instance is referenced.

classmethod one(**kwargs)

Return exactly one record. Raises error if multiple results exist.

classmethod query()

Return Query Builder related to this model

raw(query: str, params: list[Any] | tuple[Any, ...] | dict[str, Any])

Raw SQL query

to_dict()

Convert model instance to dictionary.

to_safe_instance() → Self

Wrap instance that complies with __hidden__.

update(_BaseModel__primary: str | object = <object object>, /, **kwargs)

Update current data

classmethod upsert(key: str, **kwargs)

Insert or update a record based on primary key.

classmethod where(**kwargs)

Basic select operation

class luminadb.models.Foreign(column: str, target: str | Type[Model])

Bases: Constraint

Foreign constraint

apply(type_: BuilderColumn)

Apply this constraint to an column

on_delete(constraint: ConstraintEnum)

On delete constraint

on_update(constraint: ConstraintEnum)

On update constraint

resolve()

Resolve if current target is a Model

property target

Target foreign constraint

class luminadb.models.Primary(column: str, auto: bool = False)

Bases: Constraint

Primary constraint

Accepts optional auto flag to enable auto-increment on integer primary columns when using the BuilderColumn API.

apply(type_: BuilderColumn)

Apply this constraint as primary. If auto was requested, enable auto increment on the builder column as well.

property auto: bool

Auto increment

class luminadb.models.QueryBuilder(model: Type[T])

Bases: Generic[T]

Query builder for Model ORM

count() → int

Count how much data is within this operation

delete()

Delete data based on the filter

fetch() → list[T]

Fetch data from table

fetch_one() → T | None

Fetch one data from table

limit(value: int)

Sets limit

offset(value: int)

Sets offset

order_by(column: str, descending: bool = False)

Order the query by a column

patch(**kwargs: Any)

Update a data based on the filter according to passed keyword args

throw()

Set when fetch() returns nothing, will raise an error

update(**kwargs: Any)

Update a data based on the filter according to passed keyword args

where(**kwargs: Any)

Sets conditioning

class luminadb.models.Unique(column: str)

Bases: Constraint

Unique constraint

apply(type_: BuilderColumn)

Apply this constraint to an column

luminadb.models.hook(fn_or_name: Callable[[Model], None]) → staticmethod[[Callable[[Model], None]], None]

luminadb.models.hook(fn_or_name: str)

Register a hook

luminadb.models.model(db: Database, type_checking: bool = False)

Initiate Model API compatible classes. Requires target to be a dataclass, the app automatically injects dataclass if this isn’t a dataclass.

Use type_checking if you want automatic runtime type checker.

luminadb.models.validate(fn_or_column: FuncT) → staticmethod[[FuncT], bool]

luminadb.models.validate(fn_or_column: str, reason: str | None = None)

Register a validator