We don't have any specific plans at this moment. It is not easy to integrate ORM with async frameworks. For good database performance it is better to have as few concurrent transactions as possible and for transactions to be as short as possible. With async frameworks it is typical to have a big number of long-lived concurrent coroutines. It is not efficient from the database point of view to have a large number of long-lived transactions. I think it is better in async application to access database from a separate data access layer and communicate with it from async code using a queue. Then database access layer can use short sequential transactions

csa3d, you can handle it using __init__ methods: class Fruit(db.Entity): color = Optional(str) def __init__(self, color='green'): self.color = color class Apple(Fruit): def __init__(self, color='red'): super().__init__(color)

Thank you. Is it possible to pass pony’s Query objects via such kind of queue?

I'm getting a obj._session_cache_ error

No, because query should be executed inside a transaction (that is, inside a db_session). I think you need to convert Pony object to some JSON-like data and pass it through queue. ORM object's attributes may be lazy. Sometimes the value of attribute is not loaded until you access that attribute, and at this moment implicit query goes to the database to load attribute value under the hood. This can be executed inside transaction. But if you are working with data outside of transaction, you cannot load lazy attributes anymore, so all necessary information should be loaded beforehand in the data access layer. I think that implicit converting of ORM objects to plain JSON structures may be inconvenient, but it is a price of combining transactions and async code. This is a trade-off actually. Pony uses transactions & IdentityMap pattern which may be very efficient for short synchronous transactions and provide great data consistency guarantees. Some other ORMs use simpler ActiveRecord pattern instead. They can abandon transactions and work with database without consistency guarantees. It can lead to some data corruption caused by unresolved write conflicts, but such ORMs can be used in transaction-less mode with async code. The example is Peewee ORM, I think you can use it with async frameworks. Maybe it suits your tradeoffs better for async application. Maybe some time in the future we can support transaction-less mode in PonyORM too, but it required to massive changes in architecture, as currently Pony is heavily oriented toward consistent transactions

Can you show a traceback?

Since I am only using one thread, that should mean the pool size will not ever be more than one. Right?

How do i update an item in an array ?

Yes, if your application is single-threaded, Pony will use at most one connection per process

Use add instead