def test_override_attributes(self): class SomeObject(object): pass class SomeOtherObject(object): pass ctx = SessionContext(create_session) assign_mapper( ctx, SomeObject, table, properties={ # this is the current workaround for class attribute name/collection collision: specify collection_class # explicitly. when we do away with class attributes specifying collection classes, this wont be # needed anymore. 'options': relation(SomeOtherObject, collection_class=list) }) assign_mapper(ctx, SomeOtherObject, table2) class_mapper(SomeObject) s = SomeObject() s.id = 1 s.data = 'hello' sso = SomeOtherObject() s.options.append(sso) ctx.current.flush() ctx.current.clear() assert SomeObject.get_by(id=s.id).options[0].id == sso.id
def test_dont_clobber_methods(self): class MyClass(object): def expunge(self): return "an expunge !" assign_mapper(ctx, MyClass, table2) assert MyClass().expunge() == "an expunge !"
def assign_and_create(obj, table, **localkw): table.tometadata(meta) sendkw = dict([(k, v) for k, v in localkw.items()]) sendkw.update(kw) assign_mapper(session_context, obj, table, **sendkw) checkfirst = False import sys table.create(meta.engine, checkfirst=checkfirst)
def __init__(self, timeout): global visit_class super(SqlAlchemyVisitManager,self).__init__(timeout) visit_class_path = config.get("visit.saprovider.model", "turbogears.visit.savisit.TG_Visit") visit_class = load_class(visit_class_path) bind_meta_data() if visit_class is TG_Visit: assign_mapper(session.context, visit_class, visits_table)
def test_override_attributes(self): sso = SomeOtherObject.query().first() assert SomeObject.query.filter_by(id=1).one().options[0].id == sso.id s2 = SomeObject(someid=12) s3 = SomeOtherObject(someid=123, bogus=345) class ValidatedOtherObject(object):pass assign_mapper(ctx, ValidatedOtherObject, table2, validate=True) v1 = ValidatedOtherObject(someid=12) try: v2 = ValidatedOtherObject(someid=12, bogus=345) assert False except exceptions.ArgumentError: pass
def setUp(self): global SomeObject, SomeOtherObject, ctx class SomeObject(object):pass class SomeOtherObject(object):pass ctx = SessionContext(create_session) assign_mapper(ctx, SomeObject, table, properties={ 'options':relation(SomeOtherObject) }) assign_mapper(ctx, SomeOtherObject, table2) s = SomeObject() s.id = 1 s.data = 'hello' sso = SomeOtherObject() s.options.append(sso) ctx.current.flush() ctx.current.clear()
def test_override_attributes(self): class SomeObject(object):pass class SomeOtherObject(object):pass ctx = SessionContext(create_session) assign_mapper(ctx, SomeObject, table, properties={ # this is the current workaround for class attribute name/collection collision: specify collection_class # explicitly. when we do away with class attributes specifying collection classes, this wont be # needed anymore. 'options':relation(SomeOtherObject, collection_class=list) }) assign_mapper(ctx, SomeOtherObject, table2) class_mapper(SomeObject) s = SomeObject() s.id = 1 s.data = 'hello' sso = SomeOtherObject() s.options.append(sso) ctx.current.flush() ctx.current.clear() assert SomeObject.get_by(id=s.id).options[0].id == sso.id
def assign(*args, **kw): """Map tables to objects with knowledge about the session context.""" return assign_mapper(session.context, *args, **kw)
Column( "dataset_id", Integer, ForeignKey( "dataset.id" ) ), Column( "name", String(255) ) ) Event.table = Table( "event", metadata, Column( "id", Integer, primary_key=True ), Column( "create_time", DateTime, PassiveDefault( func.current_timestamp() ) ), Column( "update_time", DateTime, PassiveDefault( func.current_timestamp() ), onupdate=func.current_timestamp() ), Column( "history_id", Integer, nullable=True ), Column( "user_id", Integer, ForeignKey( "galaxy_user.id" ), nullable=True ), Column( "message", TrimmedString( 1024 ) ) ) # With the tables defined we can define the mappers and setup the # relationships between the model objects. assign_mapper( context, Dataset, Dataset.table, properties=dict( children=relation( Dataset, cascade="delete", backref=backref("parent", foreignkey=Dataset.table.c.id ) ) ) ) # assign_mapper( model.Query, model.Query.table, # properties=dict( datasets=relation( model.Dataset.mapper, backref="query") ) ) assign_mapper( context, History, History.table, properties=dict( datasets=relation( Dataset, backref="history", lazy=False, order_by=asc(Dataset.table.c.hid) ) ) ) assign_mapper( context, User, User.table, properties=dict( histories=relation( History, backref="user", order_by=desc(History.table.c.update_time) ) ) ) assign_mapper( context, JobToInputDatasetAssociation, JobToInputDatasetAssociation.table, properties=dict( job=relation( Job ), dataset=relation( Dataset ) ) )
def assign(*args, **kw): """Map tables to objects with knowledge about the session context.""" return assign_mapper(session.context, *args, **kw)
def assign_mapper(class_, *args, **kwargs): assignmapper.assign_mapper(objectstore.context, class_, *args, **kwargs)
def update_model(self, model): meta = model.meta ctx = model.ctx class User(object): def __init__( self, username, uid=None, password=None, group_uid=None, ): self.id = id self.username = username self.password = password self.group_uid = group_uid def __repr__(self): return "User(%(username)s)" % self.__dict__ class Group(object): def __init__(self, name=None): self.name = name def __repr__(self): return "Group(%(name)s)" % self.__dict__ class Role(object): def __init__(self, name=None): self.name = name def __repr__(self): return "Role(%(name)s)" % self.__dict__ # Tables groups_table = Table( "groups", meta, Column("uid", Integer, primary_key=True), Column("name", String(255), unique=True, nullable=False), ) roles_table = Table( "roles", meta, Column("uid", Integer, primary_key=True), Column("name", String(255), unique=True, nullable=False), ) users_table = Table( "users", meta, Column("uid", Integer, primary_key=True), Column("username", String(255), unique=True, nullable=False), Column("password", String(255), nullable=False), Column("group_uid", Integer, ForeignKey("groups.uid")), ) users_roles_table = Table( # many:many relation table "users_roles", meta, Column("user_uid", Integer, ForeignKey("users.uid")), Column("role_uid", Integer, ForeignKey("roles.uid")), ) groups_mapper = assign_mapper( ctx, Group, groups_table, properties={ "users": relation(User) } ) users_mapper = assign_mapper( ctx, User, users_table, properties={ "roles": relation(Role, lazy=True, secondary=users_roles_table), "group": relation(Group), } ) roles_mapper = assign_mapper( ctx, Role, roles_table, properties={ "users": relation(User, lazy=True, secondary=users_roles_table) } ) model.User = User model.Group = Group model.Role = Role return model
def __init__(cls, clsname, bases, dict): table_name = clsname.lower() columns = [] relations = {} autoload = False _metadata = getattr(sys.modules[cls.__module__], "__metadata__", metadata) version_id_col = None version_id_col_object = None table_opts = {} if 'mapping' in dict: found_pk = False members = inspect.getmembers(dict.get('mapping')) for name, value in members: if name == '__table__': table_name = value continue if '__metadata__' == name: _metadata = value continue if '__autoload__' == name: autoload = True continue if '__version_id_col__' == name: version_id_col = value if '__table_opts__' == name: table_opts = value if name.startswith('__'): continue if isinstance(value, column): if value.primary_key == True: found_pk = True if value.foreign_key: col = Column(value.colname or name, value.coltype, value.foreign_key, primary_key=value.primary_key, *value.args, **value.kwargs) else: col = Column(value.colname or name, value.coltype, primary_key=value.primary_key, *value.args, **value.kwargs) columns.append(col) continue if isinstance(value, relationship): relations[name] = value if not found_pk and not autoload: col = Column('id', Integer, primary_key=True) cls.mapping.id = col columns.append(col) assert _metadata is not None, "No MetaData specified" ActiveMapperMeta.metadatas.add(_metadata) if not autoload: cls.table = Table(table_name, _metadata, *columns, **table_opts) cls.columns = columns else: cls.table = Table(table_name, _metadata, autoload=True, **table_opts) cls.columns = cls.table._columns # check for inheritence if version_id_col is not None: version_id_col_object = getattr(cls.table.c, version_id_col, None) assert (version_id_col_object is not None, "version_id_col (%s) does not exist." % version_id_col) if hasattr(bases[0], "mapping"): cls._base_mapper = bases[0].mapper assign_mapper(objectstore.context, cls, cls.table, inherits=cls._base_mapper, version_id_col=version_id_col_object) else: assign_mapper(objectstore.context, cls, cls.table, version_id_col=version_id_col_object) cls.relations = relations ActiveMapperMeta.classes[clsname] = cls process_relationships(cls) super(ActiveMapperMeta, cls).__init__(clsname, bases, dict)
climateCodeToName = { 'normal': 'Temperate', 'desert': 'Desert', 'hilly': 'Arctic', 'candy': 'Toyland', } climateNamesToCode = dict([(v, k) for k, v in climateCodeToName.iteritems()]) class User(object): def canManage(self, user): return self is user class Server(object): def touch(self): self.config_changed = datetime.utcnow() self.flush() class Version(object): pass assign_mapper(ctx, User, users_table) assign_mapper(ctx, Server, servers_table) assign_mapper(ctx, Version, openttd_versions_table)
def __init__(cls, clsname, bases, dict): table_name = clsname.lower() columns = [] relations = {} autoload = False _metadata = getattr(sys.modules[cls.__module__], "__metadata__", metadata) version_id_col = None version_id_col_object = None table_opts = {} if 'mapping' in dict: found_pk = False members = inspect.getmembers(dict.get('mapping')) for name, value in members: if name == '__table__': table_name = value continue if '__metadata__' == name: _metadata= value continue if '__autoload__' == name: autoload = True continue if '__version_id_col__' == name: version_id_col = value if '__table_opts__' == name: table_opts = value if name.startswith('__'): continue if isinstance(value, column): if value.primary_key == True: found_pk = True if value.foreign_key: col = Column(value.colname or name, value.coltype, value.foreign_key, primary_key=value.primary_key, *value.args, **value.kwargs) else: col = Column(value.colname or name, value.coltype, primary_key=value.primary_key, *value.args, **value.kwargs) columns.append(col) continue if isinstance(value, relationship): relations[name] = value if not found_pk and not autoload: col = Column('id', Integer, primary_key=True) cls.mapping.id = col columns.append(col) assert _metadata is not None, "No MetaData specified" ActiveMapperMeta.metadatas.add(_metadata) if not autoload: cls.table = Table(table_name, _metadata, *columns, **table_opts) cls.columns = columns else: cls.table = Table(table_name, _metadata, autoload=True, **table_opts) cls.columns = cls.table._columns if version_id_col is not None: version_id_col_object = getattr(cls.table.c, version_id_col, None) assert(version_id_col_object is not None, "version_id_col (%s) does not exist." % version_id_col) # check for inheritence if hasattr(bases[0], "mapping"): cls._base_mapper= bases[0].mapper assign_mapper(objectstore.context, cls, cls.table, inherits=cls._base_mapper, version_id_col=version_id_col_object) else: assign_mapper(objectstore.context, cls, cls.table, version_id_col=version_id_col_object) cls.relations = relations ActiveMapperMeta.classes[clsname] = cls process_relationships(cls) super(ActiveMapperMeta, cls).__init__(clsname, bases, dict)
def assign_mapper(class_, *args, **kwargs): assignmapper.assign_mapper(objectstore.context, class_, *args, **kwargs)
def update_model(self, model): meta = model.meta ctx = model.ctx class User(object): def __init__( self, username, uid=None, password=None, group_uid=None, ): self.id = id self.username = username self.password = password self.group_uid = group_uid def __repr__(self): return "User(%(username)s)" % self.__dict__ class Group(object): def __init__(self, name=None): self.name = name def __repr__(self): return "Group(%(name)s)" % self.__dict__ class Role(object): def __init__(self, name=None): self.name = name def __repr__(self): return "Role(%(name)s)" % self.__dict__ # Tables groups_table = Table( "groups", meta, Column("uid", Integer, primary_key=True), Column("name", String(255), unique=True, nullable=False), ) roles_table = Table( "roles", meta, Column("uid", Integer, primary_key=True), Column("name", String(255), unique=True, nullable=False), ) users_table = Table( "users", meta, Column("uid", Integer, primary_key=True), Column("username", String(255), unique=True, nullable=False), Column("password", String(255), nullable=False), Column("group_uid", Integer, ForeignKey("groups.uid")), ) users_roles_table = Table( # many:many relation table "users_roles", meta, Column("user_uid", Integer, ForeignKey("users.uid")), Column("role_uid", Integer, ForeignKey("roles.uid")), ) groups_mapper = assign_mapper(ctx, Group, groups_table, properties={"users": relation(User)}) users_mapper = assign_mapper(ctx, User, users_table, properties={ "roles": relation(Role, lazy=True, secondary=users_roles_table), "group": relation(Group), }) roles_mapper = assign_mapper(ctx, Role, roles_table, properties={ "users": relation(User, lazy=True, secondary=users_roles_table) }) model.User = User model.Group = Group model.Role = Role return model
Column("create_time", DateTime, PassiveDefault(func.current_timestamp())), Column("update_time", DateTime, PassiveDefault(func.current_timestamp()), onupdate=func.current_timestamp()), Column("history_id", Integer, nullable=True), Column("user_id", Integer, ForeignKey("galaxy_user.id"), nullable=True), Column("message", TrimmedString(1024))) # With the tables defined we can define the mappers and setup the # relationships between the model objects. assign_mapper(context, Dataset, Dataset.table, properties=dict(children=relation( Dataset, cascade="delete", backref=backref("parent", foreignkey=Dataset.table.c.id)))) # assign_mapper( model.Query, model.Query.table, # properties=dict( datasets=relation( model.Dataset.mapper, backref="query") ) ) assign_mapper( context, History, History.table, properties=dict(datasets=relation(Dataset, backref="history", lazy=False, order_by=asc(Dataset.table.c.hid))))
session.flush() return pend @classmethod def get_by_email_address(cls, email_address): ''' Returns a user identified by email_address @param cls: The user class @param email_address: Email identifying the user @return: User identified by email_address ''' return session.query(cls).get_by(email_address=email_address) assign_mapper(session.context, RegistrationPendingUser, registration_pending_user_table) # def newRegistrationPendingUser(user_name, # email_address, # display_name, # password, # validation_key # ): # pend = RegistrationPendingUser( # user_name = user_name, # email_address = email_address, # display_name = display_name, # password = password, # validation_key = validation_key # ) # session.save(pend)
if not self.lang == "None": lexer = get_lexer_by_name(self.lang, stripall=True) formatter = HtmlFormatter(linenos=True, cssclass="source") self._formatted_content = highlight(self.content, lexer, formatter) self.flush() else: self._formatted_content = cgi.escape(self.content) self.flush() return self._formatted_content def _set_formatted_content(self, content): self._formatted_content = content formatted_content = property(_get_formatted_content, _set_formatted_content) def _get_formatted_lines(self): return self.formatted_content formatted_lines = property(_get_formatted_lines) class Setting(object): pass assign_mapper(session.context, Paste, paste_table, properties={ "_formatted_content": paste_table.c.formatted_content } ) assign_mapper(session.context, Setting, setting_table)