Metadata-Version: 2.1
Name: asyncom
Version: 0.2.0
Summary: Small and partial Obejct mapper on top of sqlalchemy for async
Home-page: https://github.com/vinissimus/asyncom
Author: Jordi Collell
Author-email: jordic@gmail.com
License: MIT license
Keywords: asyncom
Platform: UNKNOWN
Classifier: Development Status :: 2 - Pre-Alpha
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Natural Language :: English
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Description-Content-Type: text/markdown
Requires-Dist: sqlalchemy
Requires-Dist: asyncpg
Requires-Dist: databases


# AsyncOM

Async OM it's a super basic Object mapper based almost all on sqlalchemy
ORM layer.

We use the declarative extension for building the classes, and also,
factor instances of them on querys. (*Limited support)

There is still no support for relations.

Depens on [encode/databases](https://github.com/encode/databases) dependency.


## Motivation

I don't like the asyncpgsa approach where they are just using,
the core layer, to build run the sqlgenerator. I like to build,
around the declarative layer of sqlachemy, and later found that
I can patch some of the methods on the session.query, to
use it's own sql generator, and turn async the query system.

Object persistent is minimal, and needs some love.


## Usage

```python

from sqlalchemy.ext.declarative import declarative_base
import sqlalchemy as sa
from databases import DatabaseURL

Base = declarative_base()


class OrmTest(Base):
    __tablename__ = 'orm_test'

    id = sa.Column(sa.Integer, primary_key=True)
    name = sa.Column(sa.String(100), index=True)
    value = sa.Column(sa.Text)

# Instead of usign Database from databases, you can use:
db = OMDatabase(DatabaseURL('postgres://root@postgres:{port}/guillotina'))

# instances of the object can be created with:
test = OrmTest(name='xx', value='yy')
await db.add(test)

print(test.id)  # pk column is correct set

# get an instance
ins = await db.query(OrmTest).get(1)

total = await db.query(OrmTest).count()
assert total == 1

# remove it
await db.delete(ins)

# filter them
res = await db.query(OrmTest).filter(
    OrmTest.name.like('xx')).all()

# Or just iterate over the results with a cursor:
async for row in db.query(OrmTest).filter(OrmTest.name.like('xx')):
    print(f'Row {row.name}: {row.value}')


# There is basic support for table inheritance query OneToOne


# Look at tests
```




## Changelog

0.2.0
----
- Fix bug on column.defaults

0.1.9
----
- Added Column default and onupdate on update and add
  (only for scalar values and callables)
- Added small proxy method on OMDatabaes, to raw asyncpg connection

0.1.8
---
- Yaml data importer

0.1.7
----
- Support adding basic inherited models

0.1.6
---
- query should be an async iterator

0.1.5
---
- Load inherited models.

0.1.4
----
- query(Object).get should return None if not found

0.1.3
----
- Fixes and improvements. Lay out basic API

0.1.0 (2019-04-07)
------------------

* First release on PyPI.


