Hey, I'm trying to create Entities without having to have a Database() already set up. So basically I use a different class (later = Later(), which just stores them in a list when using later.Entity), and at a later time try to get it into the database object: later.attach(db). I keep getting lost in those metaclass inherence problems. Any Idea how we could make this work? I'm thinking about something like flask's blueprints here. Here is my code so far: # -*- coding: utf-8 -*- from pony import orm from pony.orm import PrimaryKey, Required, Optional, Set from pony.orm.core import EntityMeta, Entity from luckydonaldUtils.logger import logging # from ...secrets import POSTGRES_HOST, POSTGRES_USER, POSTGRES_PASSWORD, POSTGRES_DB __author__ = 'luckydonald' # __all__ = [] logger = logging.getLogger(__name__) class LaterMeta(EntityMeta): def __init__(self, name, bases, cls_dict): # self = later.Entity super(EntityMeta, self).__init__(name, bases, cls_dict) self._database_ = None # When created, check the LaterMeta class for the database for base_class in bases: if isinstance(base_class, LaterMeta): base_class._later.entities.append((self, name, bases, cls_dict)) # end if # end for # end def # end class class Later(object): """ :var Entity: LaterMeta """ def __init__(self): self._database_ = orm.Database() self.Entity = type.__new__(LaterMeta, 'Later', (Test,), {}) # type: LaterMeta self.Entity._later = self self.entities = list() def attach(self, database): class EntityMetaDatabased(EntityMeta): #def __new__(meta, name, bases, cls_dict): # return type.__new__(meta, name, bases, cls_dict) # pass __new__ = type.__new__ __init__ = object.__init__ #def __init__(*args): #type.__init__(name, bases, cls_dict) # pass e = EntityMetaDatabased() #class EntittyLater(database.Entity): # pass for table_args in self.entities: #entity = EntityMetaDatabased.__init__(*table_args) # lel = type.__new__(EntityMeta, 'Entity', (table_args[0].__class__,), {}) this = table_args[0] EntityMeta.__init__(this, table_args[0].__name__, (self,), {}) #database.Entity() # entity = type.__new__(EntittyLater, 'Entity', (), {}) # type: Entity pass later = Later() class Project(later.Entity): id = PrimaryKey(int, auto=True) proj = Required(str) # project identifier user = Required('User') default_lang = Optional(str) translations = Set('Translation') access = Set('Access') class User(later.Entity): id = PrimaryKey(int, auto=True) projects = Set(Project) translations = Set('Translation') access = Set('Access') states = Set('State') class Translation(later.Entity): id = PrimaryKey(int, auto=True) lang = Optional(str) project = Required(Project) key = Optional(str) # The programic key for the translation value = Optional(str) # The text user = Required(User) approved = Optional(bool) class Access(later.Entity): id = PrimaryKey(int, auto=True) project = Required(Project) user = Optional(User) # Either token or user token = Optional(str) # Either token or user class State(later.Entity): user = Required(User) chat_id = PrimaryKey(int) value = Optional(int) db = orm.Database() later.attach(db) db.bind(provider='sqlite', filename=":memory:", create_db=True) db.generate_mapping()

Can you remind for what purpose do you use this pattern? ``` def foo(db): class Bar(db.Entity) pass db = Database() foo(db) ``` Is it to split entities to several modules?

obj = MyObject.create_or_update(foo=1, bar=2) and parent_object.some_collection.create_or_update(foo=1, bar=2)

Hi @luckydonald, I'll think about it, may be we can change the process of entity class creation to make it more flexible. I cannot promise any specific at this point, as it may be a complex task

What would be the Ponyorm way to do SELECT * FROM UserAccess WHERE user = ? AND project = ? to check if a given User u has UserAccess to a given Project p?

Hi @luckydonald! First, it is not necessary to have UserAccess entity in this diagram, because it is equivalent to many-to-many relationship. If you replace your current code with: class User(db.Entity): ... access_projects = Set("Project", reverse="access_users", table="useraccess", column="project") class Project(db.Entity): ... access_users = Set("User", reverse="access_projects", column="user") You even don't need a migration to work with previous tables The real need in separate UserAccess entity arises only when it has some additional attributes, like access_level or something like that Anyway, if you really need to have a separate UserAccess entity, you can use exists type of query: if not (p.access_all or UserAccess.exists(user=u, project=p)): return 403, {...} Also you can get all accessible projects for user using attribute lifting: user.access_projects.project will return a collection of all accessible projects to a specific user. Similar, project.access_users.user returns a collections of all users which can access a specific project. You can use attribute lifting in queries: select(p for p in Project if (p.access_all or u in p.access_users.user) and <some other conditions>)

At this moment Pony does not support enums. You can define the following class class LANGUAGES: EN = 'EN' RU = 'RU' class MyEntity(db.Entity): lang = Required(str) ... MyEntity(lang=LANGUAGES.EN)

Coming ? https://github.com/ponyorm/pony/pull/392

Hi @luckydonald! First, it is not necessary to have UserAccess entity in this diagram, because it is equivalent to many-to-many relationship. If you replace your current code with: class User(db.Entity): ... access_projects = Set("Project", reverse="access_users", table="useraccess", column="project") class Project(db.Entity): ... access_users = Set("User", reverse="access_projects", column="user") You even don't need a migration to work with previous tables The real need in separate UserAccess entity arises only when it has some additional attributes, like access_level or something like that Anyway, if you really need to have a separate UserAccess entity, you can use exists type of query: if not (p.access_all or UserAccess.exists(user=u, project=p)): return 403, {...} Also you can get all accessible projects for user using attribute lifting: user.access_projects.project will return a collection of all accessible projects to a specific user. Similar, project.access_users.user returns a collections of all users which can access a specific project. You can use attribute lifting in queries: select(p for p in Project if (p.access_all or u in p.access_users.user) and <some other conditions>)

Something like this: user = User.get(id=owner_id) if user is None: return 404 project = user.projects.select(lambda p: p.name == project_key).get() if project is None: return 404 original = project.originals.select(lambda o: o.name == language).get() if original is None: return 404 translation = original.translations.select(lambda t: t.lang == translation_key).get() if translation is None: return 404