def setup_mappers(cls): class Descriptions(_base.BasicEntity): pass class Values(_base.BasicEntity): pass class CustomValues(_base.BasicEntity, list): def __init__(self, *args): self.extend(args) def __composite_values__(self): return self desc_values = select( [values, descriptions.c.d1, descriptions.c.d2], descriptions.c.id == values.c.description_id ).alias('descriptions_values') mapper(Descriptions, descriptions, properties={ 'values': relationship(Values, lazy='dynamic'), 'custom_descriptions': composite( CustomValues, descriptions.c.d1, descriptions.c.d2), }) mapper(Values, desc_values, properties={ 'custom_values': composite(CustomValues, desc_values.c.v1, desc_values.c.v2), })
def test_addr_composite(self): flds = "name addr1 addr2 addr3 addr4 email fax phone".split() class B(DeclarativeBaseGuid): __tablename__ = "b_table" def __init__(self, **kwargs): for k, v in kwargs.items(): setattr(self, k, v) l = [] for fld in flds: col = Column(fld, TEXT()) setattr(B, fld, col) l.append(col) B.addr = composite(Address, *l) s = session() a = B(addr1="foo") assert a.addr a.addr.fax = "baz" assert a.addr1 == "foo" assert a.addr.addr1 == "foo" assert a.addr.fax == "baz" s.add(a) s.flush()
def setup_mappers(cls): a, b = cls.tables.a, cls.tables.b class A(cls.Comparable): pass class B(cls.Comparable): pass class C(cls.Comparable): def __init__(self, b1, b2): self.b1, self.b2 = b1, b2 def __composite_values__(self): return self.b1, self.b2 def __eq__(self, other): return isinstance(other, C) and \ other.b1 == self.b1 and \ other.b2 == self.b2 mapper(A, a, properties={ 'b2':relationship(B), 'c':composite(C, 'b1', 'b2') }) mapper(B, b)
class Reporter(Base): __tablename__ = "reporters" id = Column(Integer(), primary_key=True) first_name = Column(String(30), doc="First name") last_name = Column(String(30), doc="Last name") email = Column(String(), doc="Email") favorite_pet_kind = Column(PetKind) pets = relationship("Pet", secondary=association_table, backref="reporters") articles = relationship("Article", backref="reporter") favorite_article = relationship("Article", uselist=False) @hybrid_property def hybrid_prop(self): return self.first_name column_prop = column_property(select([func.cast(func.count(id), Integer)]), doc="Column property") composite_prop = composite(CompositeFullName, first_name, last_name, doc="Composite")
def i18nString(name: str, with_plural: bool=False, **kwargs) -> CompositeProperty: """ Translatable String Usage: >>> news.topic = ('Deutscher Titel', 'English Topic') >>> news.topic.en 'English Topic' >>> template.render('{{ _(news.topic) }}') 'Deutscher Titel' :param name: Prefix of column names :param with_plural: Does this Column can have a plural? If true, it will generate for each language a \*_pl column additionally. :param kwargs: Additional Parameters passed to Column Instance :rtype: :class:`_i18nObject` as :class:`MutableObject(**environment.langs)` """ dwargs = dict(nullable=False, server_default='') dwargs.update(kwargs) columns = [] for lang in environment.langs: columns.append(Column('%s_%s' % (name, lang), sqUnicode, **dwargs)) if with_plural: for lang in environment.langs: columns.append(Column('%s_%s_pl' % (name, lang), sqUnicode, **dwargs)) cls = composite(with_plural and _i18nPluralizedObject or _i18nObject, *columns, comparator_factory=_i18nObjectComparator) return cls
def prep_database(): global myengine # create engine myengine = create_engine('sqlite:///:memory:', echo=False) # setup table metadata metadata = MetaData() table_infomatic = Table('infomatic', metadata, Column('id', Integer, primary_key=True), Column('info', Unicode(255)), Column('expectedoffset', Integer), Column('utcdate', DateTime), # for TZAwareDateTime Column('tzname', Unicode), # for TZAwareDateTime Column('tzoffset', Integer)) # for TZAwareDateTime # setup mappings mapper(InfoMatic, table_infomatic, properties={ 'info': table_infomatic.c.info, 'expectedoffset': table_infomatic.c.expectedoffset, 'tzawaredate': composite(TZAwareDateTime, table_infomatic.c.utcdate, table_infomatic.c.tzname, table_infomatic.c.tzoffset) }) # create all tables metadata.create_all(myengine)
class Vehicle(Base): __tablename__ = "vehicles" id = Column(types.Integer(), Sequence("seq_id"), primary_key=True, doc="The primary key") name = Column(types.String(length=50), doc="The name of the vehicle") type = Column(types.Enum(VehicleType, name="vehicle_type"), nullable=False) created_at = Column(types.DateTime()) paint = Column(types.Enum(*COLORS, name="colors")) is_used = Column(types.Boolean) @property def lower_name(self): return self.name.lower() _engine_cylinders = Column("engine_cylinders", types.BigInteger()) _engine_displacement = Column( "engine_displacement", types.Numeric(asdecimal=True, precision=10, scale=2)) _engine_type = Column("engine_type", types.String(length=25)) _engine_fuel_type = Column("engine_fuel_type", types.String(length=10)) engine = orm.composite(Engine, _engine_cylinders, _engine_displacement, _engine_type, _engine_fuel_type) _owner_id = Column("owner_id", types.Integer(), ForeignKey(Owner.id)) owner = orm.relationship(Owner, backref="vehicles") def clean_name(self): if self.name == "invalid": raise ValidationError("invalid vehicle name")
def setup_mappers(cls): foo = cls.tables.foo Point = cls._type_fixture() cls.mapper_registry.map_imperatively( Foo, foo, properties={"data": composite(Point, foo.c.x, foo.c.y)})
def setup_mappers(cls): a, b = cls.tables.a, cls.tables.b class A(cls.Comparable): pass class B(cls.Comparable): pass class C(cls.Comparable): def __init__(self, b1, b2): self.b1, self.b2 = b1, b2 def __composite_values__(self): return self.b1, self.b2 def __eq__(self, other): return (isinstance(other, C) and other.b1 == self.b1 and other.b2 == self.b2) mapper( A, a, properties={ "b2": relationship(B), "c": composite(C, "b1", "b2") }, ) mapper(B, b)
class User(decl_base): __tablename__ = "user" id: Mapped[int] = mapped_column(primary_key=True) name: Mapped[str] = mapped_column() address: Mapped[Address] = composite(Address, mapped_column())
def __init__(cls, classname, bases, dict_): new_fields = {} for name, attribute in dict_.items(): if type(attribute) is ControllerData: if attribute._writable: requested_colname = "_{0}_requested".format(name) requested_column = Column(requested_colname, *attribute._args, nullable=True, **attribute._kwargs) new_fields[requested_colname] = requested_column actual_colname = "_{0}".format(name) actual_column = Column(actual_colname, *attribute._args, nullable=True, **attribute._kwargs) new_fields[actual_colname] = actual_column composite_colname = "{0}".format(name) new_fields[composite_colname] = composite(ControllerCompositeColumn, actual_column, requested_column) else: new_fields[name] = Column(name, *attribute._args, **attribute._kwargs) # Set new fields dict_.update(new_fields) for new_field_name, new_field in new_fields.items(): setattr(cls, new_field_name, dict_[new_field_name]) super(BaseClsMeta, cls).__init__(classname, bases, dict_)
class Unit(Base): __tablename__ = 'units' id = Column(Integer, primary_key=True) battle_id = Column(ForeignKey('battles.id', name='fk_unit_battle'), nullable=False) owner_id = Column(ForeignKey('players.id')) type = Column(String, nullable=False) xp = Column(Integer, nullable=False) level = Column(Integer, nullable=False) health = Column(Integer, nullable=False) poison_count = Column(Integer) did_move = Column(Boolean) did_attack = Column(Boolean) did_fix = Column(Boolean) did_occupy = Column(Boolean) x = Column(Integer, nullable=False) y = Column(Integer, nullable=False) cell = composite(Cell, x, y) battle = relationship("Battle", back_populates="units", foreign_keys=[battle_id]) owner = relationship("Player", back_populates="units") # @hybrid_property # def cell(self): # return '{0},{1}'.format(self.x, self.y) def __repr__(self): return 'id={0},x={1},x={2},type={3},owner_id={4}'.format( self.id, self.x, self.y, self.type, self.owner_id)
class Dependency(Base): """ A binary RPM name-epoch-version-release-arch. Kind of a flyweight pattern to avoid storing the same NEVRAs multiple times as they consume a lot space. Each NEVRA must be unique (there's a unique index defined later). Referenced by Build.dependency_keys and Applied/UnappliedChange.prev/curr_dep_id """ id = Column(Integer, primary_key=True) name = Column(String, nullable=False) epoch = Column(Integer) version = Column(String, nullable=False) release = Column(String, nullable=False) arch = Column(String, nullable=False) # Composite property that can be used for queries that need to compare EVRs # RPM's way evr = composite( RpmEVR, epoch, version, release, comparator_factory=RpmEVRComparator, ) nevr = (name, epoch, version, release) nevra = (name, epoch, version, release, arch) inevra = (id, name, epoch, version, release, arch)
def InitMapper( cls, metadata, ObjectType ): cls.__table__ = Table( cls.__tablename__, metadata, Column('id', Integer, index = True, primary_key = True), Column('type_id', Integer, ForeignKey( ObjectType.id ), nullable = False), Column('parent_id', Integer, ForeignKey( "%s.id" % cls.__tablename__ ), nullable = True), Column('name', Text, nullable = False), Column('size', Integer(64), nullable = False, default = 0), Column('pos_x', Integer(64), nullable = False, default = 0), Column('pos_y', Integer(64), nullable = False, default = 0), Column('pos_z', Integer(64), nullable = False, default = 0), Column('mtime', DateTime, nullable = False, onupdate = func.current_timestamp(), default = func.current_timestamp())) cols = cls.__table__.c Index('ix_%s_position' % cls.__tablename__, cols.pos_x, cols.pos_y, cols.pos_z) mapper( cls, cls.__table__, polymorphic_on = cols.type_id, properties = { 'type': relation( ObjectType, uselist = False, backref = backref( 'objects' )), # Tree like hierarchy for objects ie. Universe => Solar systems => Planets => etc. 'children': relation( cls, backref = backref( 'parent', remote_side = [ cols.id ] )), # Object position in 3D space 'position': composite( Vector3D, cols.pos_x, cols.pos_y, cols.pos_z ), })
def setUp(self): """prep db access""" # create engine self.db_myengine = create_engine('sqlite:///:memory:', echo=False) # setup table metadata self.db_metadata = MetaData() table_infomatic = Table('infomatic', self.db_metadata, Column('id', Integer, primary_key=True), Column('info', Unicode(255)), Column('expectedoffset', Integer), Column('utcdate', DateTime), # for tzawaredate Column('tzname', Unicode), # for tzawaredate Column('tzoffset', Integer)) # for tzawaredate # setup mappings mapper(InfoMatic, table_infomatic, properties={ 'info': table_infomatic.c.info, 'expectedoffset': table_infomatic.c.expectedoffset, 'tzawaredate': composite(tzaware_datetime.TZAwareDateTime, table_infomatic.c.utcdate, table_infomatic.c.tzname, table_infomatic.c.tzoffset) }) # create all tables self.db_metadata.create_all(self.db_myengine) # create session self.session = create_session(bind=self.db_myengine, autocommit=True, autoflush=True)
def setup_mappers(cls): a, b = cls.tables.a, cls.tables.b class A(cls.Comparable): pass class B(cls.Comparable): pass class C(cls.Comparable): def __init__(self, b1, b2): self.b1, self.b2 = b1, b2 def __composite_values__(self): return self.b1, self.b2 def __eq__(self, other): return ( isinstance(other, C) and other.b1 == self.b1 and other.b2 == self.b2 ) mapper( A, a, properties={"b2": relationship(B), "c": composite(C, "b1", "b2")}, ) mapper(B, b)
class Vehicle(Base): __tablename__ = 'vehicles' id = Column(types.Integer(), Sequence('seq_id'), primary_key=True, doc='The primary key') name = Column(types.String(), doc='The name of the vehicle') type = Column(types.Enum(VehicleType), nullable=False) created_at = Column(types.DateTime()) paint = Column(types.Enum(*COLORS)) is_used = Column(types.Boolean) @property def lower_name(self): return self.name.lower() _engine_cylinders = Column('engine_cylinders', types.BigInteger()) _engine_displacement = Column( 'engine_displacement', types.Numeric(asdecimal=True, precision=10, scale=2)) _engine_type = Column('engine_type', types.String(length=25)) _engine_fuel_type = Column('engine_fuel_type', types.String(length=10)) engine = orm.composite(Engine, _engine_cylinders, _engine_displacement, _engine_type, _engine_fuel_type) _owner_id = Column('owner_id', types.Integer(), ForeignKey(Owner.id)) owner = orm.relationship(Owner, backref='vehicles')
class Environment(db.Model): model_log.info("Creating environment table") id = db.Column(db.Integer, primary_key=True) width = db.Column(db.Integer) height = db.Column(db.Integer) game_objects = db.relationship("GameObject", back_populates="environment") dim = composite(Vector, width, height)
class Vertex(base): __tablename__ = "vertices" id = Column(Integer, primary_key=True) mesh_id = Column(Integer, ForeignKey('meshes.mesh_id')) x = Column(Float) y = Column(Float) z = Column(Float) pos = composite(vec3f, x, y, z)
class User(decl_base): __tablename__ = "user" id: Mapped[int] = mapped_column(primary_key=True) name: Mapped[str] = mapped_column() address: "Address" = composite( # type: ignore mapped_column(), mapped_column(), mapped_column("zip"))
def setup_mappers(cls): foo = cls.tables.foo Point = cls._type_fixture() mapper(Foo, foo, properties={ 'data': composite(Point, foo.c.x, foo.c.y) })
def setup_mappers(cls): foo = cls.tables.foo subfoo = cls.tables.subfoo Point = cls._type_fixture() mapper(Foo, foo, properties={"data": composite(Point, foo.c.x, foo.c.y)}) mapper(SubFoo, subfoo, inherits=Foo)
def setup_mappers(cls): foo = cls.tables.foo Point = cls._type_fixture() mapper(Foo, foo, properties={'data': composite(Point, foo.c.x, foo.c.y)})
def _fixture(self): class AB(object): def __init__(self, a, b, cd): self.a = a self.b = b self.cd = cd @classmethod def generate(cls, a, b, c, d): return AB(a, b, CD(c, d)) def __composite_values__(self): return (self.a, self.b) + self.cd.__composite_values__() def __eq__(self, other): return ( isinstance(other, AB) and self.a == other.a and self.b == other.b and self.cd == other.cd ) def __ne__(self, other): return not self.__eq__(other) class CD(object): def __init__(self, c, d): self.c = c self.d = d def __composite_values__(self): return (self.c, self.d) def __eq__(self, other): return ( isinstance(other, CD) and self.c == other.c and self.d == other.d ) def __ne__(self, other): return not self.__eq__(other) class Thing(object): def __init__(self, ab): self.ab = ab stuff = self.tables.stuff mapper( Thing, stuff, properties={ "ab": composite( AB.generate, stuff.c.a, stuff.c.b, stuff.c.c, stuff.c.d ) }, ) return Thing, AB, CD
def _fixture(self): class AB: def __init__(self, a, b, cd): self.a = a self.b = b self.cd = cd @classmethod def generate(cls, a, b, c, d): return AB(a, b, CD(c, d)) def __composite_values__(self): return (self.a, self.b) + self.cd.__composite_values__() def __eq__(self, other): return ( isinstance(other, AB) and self.a == other.a and self.b == other.b and self.cd == other.cd ) def __ne__(self, other): return not self.__eq__(other) class CD: def __init__(self, c, d): self.c = c self.d = d def __composite_values__(self): return (self.c, self.d) def __eq__(self, other): return ( isinstance(other, CD) and self.c == other.c and self.d == other.d ) def __ne__(self, other): return not self.__eq__(other) class Thing: def __init__(self, ab): self.ab = ab stuff = self.tables.stuff self.mapper_registry.map_imperatively( Thing, stuff, properties={ "ab": composite( AB.generate, stuff.c.a, stuff.c.b, stuff.c.c, stuff.c.d ) }, ) return Thing, AB, CD
class HasVertex(decl_base): __tablename__ = "has_vertex" id = Column(Integer, primary_key=True) x1 = Column(Integer) y1 = Column(Integer) x2 = Column(Integer) y2 = Column(Integer) vertex = composite(Vertex._generate, x1, y1, x2, y2)
class Eigenvector(base): __tablename__ = "eigenvectors" eigen_id = Column(Integer, primary_key=True) eigen_value = Column(Float) x = Column(Float) y = Column(Float) z = Column(Float) mesh_id = Column(Integer, ForeignKey('meshes.mesh_id')) direction = composite(vec3f, x, y, z)
class Terrain(Base): __tablename__ = 'terrain' battle_id = Column(ForeignKey('battles.id'), primary_key=True) x = Column(Integer, primary_key=True) y = Column(Integer, primary_key=True) type = Column(String) cell = composite(Cell, x, y)
def setup_mappers(cls): values, descriptions = cls.tables.values, cls.tables.descriptions class Descriptions(cls.Comparable): pass class Values(cls.Comparable): pass class CustomValues(cls.Comparable, list): def __init__(self, *args): self.extend(args) def __composite_values__(self): return self desc_values = ( select(values, descriptions.c.d1, descriptions.c.d2) .where( descriptions.c.id == values.c.description_id, ) .alias("descriptions_values") ) cls.mapper_registry.map_imperatively( Descriptions, descriptions, properties={ "values": relationship(Values, lazy="dynamic"), "custom_descriptions": composite( CustomValues, descriptions.c.d1, descriptions.c.d2 ), }, ) cls.mapper_registry.map_imperatively( Values, desc_values, properties={ "custom_values": composite( CustomValues, desc_values.c.v1, desc_values.c.v2 ) }, )
class Security(Base): __tablename__ = 'securities' id = Column(Integer, primary_key=True, name='SECID') full = Column(String, name='NAME') short = Column(String, name='SHORTNAME') latin = Column(String, name='LATNAME') issuer = composite(Issuer, full, short, latin) isin = Column(String, name='ISIN') reg_number = Column(String, name='REGNUMBER') issue_size = Column(Integer, name='ISSUESIZE') face_value_amount = Column(Float, name='FACEVALUE') face_value_unit = Column(String, name='FACEUNIT') def update(self, **kwargs): for key, value in kwargs.iteritems(): if hasattr(self, key): setattr(self, key, value) def remove_attributes(self, *args): for attr_name in args: if hasattr(self, attr_name): setattr(self, attr_name, None) @property def face_value(self): if self.face_value_amount and self.face_value_unit: return Money(amount=self.face_value_amount, currency=self.face_value_unit) else: return None @face_value.setter def face_value(self, face_value): if face_value: self.face_value_amount = face_value.amount self.face_value_unit = face_value.currency else: self.face_value_amount = None self.face_value_unit = None @staticmethod def create(_id, issuer, isin, reg_number, issue_size, face_value): return Security(id=_id, issuer=issuer, isin=isin, reg_number=reg_number, issue_size=issue_size, face_value=face_value) def __repr__(self): return 'Security {} of issuer {},' \ 'registration_number {},' \ 'ISIN {},' \ 'issue size {},' \ 'face value {}'.format(self.id, self.issuer, self.reg_number, self.isin, self.issue_size, self.face_value)
def setup_mappers(cls): foo = cls.tables.foo Point = cls._type_fixture() # in this case, this is not actually a MutableComposite. # so we don't expect it to track changes mapper(Foo, foo, properties={ 'data': composite(lambda x, y: Point(x, y), foo.c.x, foo.c.y) })
def setup_mappers(cls): foo = cls.tables.foo cls.Point = cls._type_fixture() mapper( FooWithEq, foo, properties={"data": composite(cls.Point, foo.c.x, foo.c.y)}, )
def MarkdownColumn(name, deferred=False, group=None, **kwargs): """ Create a composite column that autogenerates HTML from Markdown text, storing data in db columns named with ``_html`` and ``_text`` prefixes. """ return composite(MarkdownComposite, Column(name + '_text', UnicodeText, **kwargs), Column(name + '_html', UnicodeText, **kwargs), deferred=deferred, group=group or name )
class B(ComparableEntity, BaseCls): __tablename__ = "b" id = Column(ForeignKey(BaseCls.id), primary_key=True) thing2 = Column(String(50)) comp2 = composite(XYThing, Column("x2", Integer), Column("y2", Integer)) __mapper_args__ = { "polymorphic_identity": "b", "polymorphic_load": "selectin", }
def rank_soloq(self): return composite(LeagueLeague, self.rank_soloq_tier, self.rank_soloq_rank, self.rank_soloq_points, self.rank_soloq_wins, self.rank_soloq_losses, self.rank_soloq_inactive, self.rank_soloq_hot_streak, self.rank_soloq_fresh_blood, self.rank_soloq_veteran)
class B(Base): """ A class with a many-to-one relationship to :class:`.C` via its ``c`` attribute. """ __tablename__ = "table_b" id = Column(Integer, primary_key=True) foo = Column(Integer) c_id = Column('c', Integer, ForeignKey("table_c.id")) composite_column = composite(Comp, foo, c_id) c = relationship("C")
def assert_composite_conversion(composite_class, composite_columns, graphene_field, registry, **kwargs): composite_column = composite(composite_class, *composite_columns, doc='Custom Help Text', **kwargs) graphene_type = convert_sqlalchemy_composite(composite_column, registry) assert isinstance(graphene_type, graphene_field) field = graphene_type.Field() # SQLAlchemy currently does not persist the doc onto the column, even though # the documentation says it does.... # assert field.description == 'Custom Help Text' return field
class Style(Base): """ the styma table """ __tablename__ = "styma" id = Column(Integer, name="styid", primary_key=True) alpha = Column(VARCHAR(2), nullable=False, name='alpha') digit = Column(Integer, name="digit", nullable=False) description = Column(VARCHAR(50), name="description", nullable=False) name = composite(StyElement, alpha, digit) UniqueConstraint(alpha, digit, name='idx_styno')
def setup_mappers(cls): values, descriptions = cls.tables.values, cls.tables.descriptions class Descriptions(cls.Comparable): pass class Values(cls.Comparable): pass class CustomValues(cls.Comparable, list): def __init__(self, *args): self.extend(args) def __composite_values__(self): return self desc_values = select( [values, descriptions.c.d1, descriptions.c.d2], descriptions.c.id == values.c.description_id, ).alias("descriptions_values") mapper( Descriptions, descriptions, properties={ "values": relationship(Values, lazy="dynamic"), "custom_descriptions": composite( CustomValues, descriptions.c.d1, descriptions.c.d2 ), }, ) mapper( Values, desc_values, properties={ "custom_values": composite( CustomValues, desc_values.c.v1, desc_values.c.v2 ) }, )
def setup_mappers(cls): foo = cls.tables.foo subfoo = cls.tables.subfoo cls.Point = cls._type_fixture() cls.mapper_registry.map_imperatively( Foo, foo, properties={"data": composite(cls.Point, foo.c.x, foo.c.y)}, ) cls.mapper_registry.map_imperatively(SubFoo, subfoo, inherits=Foo)
def test_should_unknown_sqlalchemy_composite_raise_exception(): class CompositeClass: def __init__(self, col1, col2): self.col1 = col1 self.col2 = col2 re_err = "Don't know how to convert the composite field" with pytest.raises(Exception, match=re_err): convert_sqlalchemy_composite( composite(CompositeFullName, (Column(types.Unicode(50)), Column(types.Unicode(50)))), Registry(), )
def InitMapper( cls, metadata, Parameter, ParameterType ): cls.__table__ = Table( cls.__tablename__, metadata, Column('param_id', ForeignKey( Parameter.id ), index = True, primary_key = True ), Column('x', Integer, nullable = False ), Column('y', Integer, nullable = False ), Column('z', Integer, nullable = False )) cols = cls.__table__.c mapper( cls, cls.__table__, inherits = Parameter, polymorphic_identity = ParameterType, exclude_properties = [ 'param_id', 'x', 'y', 'z' ], properties = { 'position': composite( Vector3D, cols.x, cols.y, cols.z ), })
def InitMapper( cls, metadata, Parameter, ParameterType, Object ): cls.__table__ = Table( cls.__tablename__, metadata, Column('param_id', ForeignKey( Parameter.id ), index = True, primary_key = True ), Column('x', Integer, default = 0, nullable = False ), Column('y', Integer, default = 0, nullable = False ), Column('z', Integer, default = 0, nullable = False ), Column('parent_id', ForeignKey( Object.id ), nullable = True )) cols = cls.__table__.c mapper( cls, cls.__table__, inherits = Parameter, polymorphic_identity = ParameterType, properties = { 'parent' : relation( Object, uselist = False ), # Object position in 3D space 'vector': composite( Vector3D, cols.x, cols.y, cols.z ), })
def i18nText(name, **kwargs): """ Translatable Text :param name: Prefix of the Column :param kwargs: Additional Parameters passed to Column Instance :rtype: :class:`_i18nObject` as :class:`MutableObject(**environment.langs)` """ dwargs = dict(nullable=False, server_default='') dwargs.update(kwargs) columns = [] for lang in environment.langs: columns.append(Column('%s_%s' % (name, lang), sqUnicodeText, **dwargs)) cls = composite(_i18nObject, *columns, comparator_factory=_i18nObjectComparator) return cls
def get_mapper_definition(newtable, columnname): """Given a Table object, return the Mapper definition for a TZAwareDateTime column""" # cycle through columns, find the utcdate, tzname, tzoffset columns column_utcdate, column_tzname, column_tzoffset = None, None, None new_column_names = {'utcdate': '%s_%s' % (columnname, TZAwareDateTimeColumnNames[0]), 'tzname': '%s_%s' % (columnname, TZAwareDateTimeColumnNames[1]), 'tzoffset': '%s_%s' % (columnname, TZAwareDateTimeColumnNames[2]) } for c in newtable.c: assert isinstance(c, Column) if c.key == new_column_names['utcdate']: column_utcdate = c elif c.key == new_column_names['tzname']: column_tzname = c elif c.key == new_column_names['tzoffset']: column_tzoffset = c if column_utcdate != column_tzname != column_tzoffset != None: break return composite(TZAwareDateTime, column_utcdate, column_tzname, column_tzoffset)
def setMapping(self): """ Map the Metadata classes to the provider database schema """ from sqlalchemy.orm import mapper, relationship, composite, synonym from sqlalchemy.sql import select, join schema = self.getSchema() alt_title_table = schema.tables['ALT_TITLE'] mapper(AlternativeTitle, alt_title_table) citation_table = schema.tables['CITATION'] mapper(ResourceLocator, citation_table, properties={ 'url': citation_table.c.ONLINERES, 'name': citation_table.c.ONLINERESNAM, 'description': citation_table.c.ONLINERESDESC, 'function': citation_table.c.ONLINERESFUNC }) resloc_res_table = schema.tables['RESLOC_RES'] a_is_resolve_table = schema.tables['A_IS_RESOLVE'] mapper(AdditionalInformation, citation_table) coupled_res_table = schema.tables['COUPLED_RES'] mapper(CoupledResource, coupled_res_table) ctrlvocab_res_table = schema.tables['CTRLVOCAB_RES'] mapper(Term, ctrlvocab_res_table) a_c_resolve_table = schema.tables['A_C_RESOLVE'] mapper(AccessConstraint, a_c_resolve_table) access_use_table = schema.tables['ACCESS_USE'] o_r_resolve_table = schema.tables['O_R_RESOLVE'] a_u_resolve_table = schema.tables['A_U_RESOLVE'] mapper(AccessUse, access_use_table) res_party_table = schema.tables['RES_PARTY'] resparty_res_table = schema.tables['RESPARTY_RES'] res_party_join = join(res_party_table, resparty_res_table) mapper(ResponsibleParty, res_party_join, properties={ 'RESPARTYID': [res_party_table.c.RESPARTYID, resparty_res_table.c.RESPARTYID], 'ROLEID': resparty_res_table.c.ROLEID, 'FIRSTNAME': res_party_table.c.FIRSTNAME, 'SURNAME': res_party_table.c.SURNAME, 'ORGID': res_party_table.c.ORGID, 'position': res_party_table.c.POSITIONTITLE, 'CONTACTID': res_party_table.c.CONTACTID }) parent_id_table = schema.tables['PARENT_ID'] metadata_table = schema.tables['METADATA'] mapper(ParentId, metadata_table, properties={ 'id': metadata_table.c.IDENTIFIER, 'codespace': metadata_table.c.CODESPACE }) mapper(Metadata, metadata_table, properties={ 'METADATAID': metadata_table.c.METADATAID, 'title': metadata_table.c.TITLE, 'alt_titles': relationship(AlternativeTitle, order_by=AlternativeTitle.ALTTITLE), 'abstract': metadata_table.c.ABSTRACT, 'RESTYP_ID': metadata_table.c.RESTYP_ID, 'resource_locators': relationship(ResourceLocator, secondary=resloc_res_table), 'unique_id': composite( UniqueId, metadata_table.c.IDENTIFIER, metadata_table.c.CODESPACE), 'parent_id': relationship(ParentId, secondary=parent_id_table, primaryjoin=(metadata_table.c.METADATAID == parent_id_table.c.METADATAID), secondaryjoin=(metadata_table.c.METADATAID == parent_id_table.c.PARENTID), uselist=False), 'coupled_resources': relationship(CoupledResource), 'terms': relationship(Term), 'SDSTYP_ID': metadata_table.c.SDSTYP_ID, 'bounding_box': composite( BoundingBox, metadata_table.c.WEST, metadata_table.c.SOUTH, metadata_table.c.EAST, metadata_table.c.NORTH), 'vertical_extent': composite( VerticalExtent, metadata_table.c.VERTEXTMIN, metadata_table.c.VERTEXTMAX, metadata_table.c.VERTEXTREF_ID), 'srs': metadata_table.c.SRSYS_ID, 'temporal_reference': composite( TemporalReference, metadata_table.c.TEMPEXBGN, metadata_table.c.TEMPEXEND, metadata_table.c.PUBDATE, metadata_table.c.REVDATE, metadata_table.c.CREATED), 'lineage': metadata_table.c.LINEAGE, 'spatial_resolutions': composite( SpatialResolution, metadata_table.c.SPARES, select(["NULL"])), 'ADDITIONAL_INFO': relationship(AdditionalInformation, secondary=a_is_resolve_table), 'ACCESS_CONSTRAINTS': relationship(AccessConstraint, order_by=AccessConstraint.ISOCODEID), 'other_access_constraints': relationship(AccessUse, secondary=o_r_resolve_table), 'use_limitations': relationship(AccessUse, secondary=a_u_resolve_table), 'RESPARTY': relationship(ResponsibleParty), 'date': metadata_table.c.MODDATE })
else: return helpers.url_for(controller='/media', action='serve', slug=self.media.slug, id=self.id, container=self.container, qualified=qualified) class MediaFullText(object): query = DBSession.query_property() mapper(MediaFile, media_files) mapper(MediaFullText, media_fulltext) _media_mapper = mapper(Media, media, order_by=media.c.title, properties={ 'fulltext': relation(MediaFullText, uselist=False, passive_deletes=True), 'author': composite(Author, media.c.author_name, media.c.author_email), 'files': relation(MediaFile, backref='media', order_by=media_files.c.type.asc(), passive_deletes=True), 'tags': relation(Tag, secondary=media_tags, backref=backref('media', lazy='dynamic', query_class=MediaQuery), collection_class=TagList, passive_deletes=True), 'categories': relation(Category, secondary=media_categories, backref=backref('media', lazy='dynamic', query_class=MediaQuery), collection_class=CategoryList, passive_deletes=True), 'comments': dynamic_loader(Comment, backref='media', query_class=CommentQuery, passive_deletes=True), 'comment_count': column_property( sql.select([sql.func.count(comments.c.id)], media.c.id == comments.c.media_id).label('comment_count'), deferred=True), 'comment_count_published': column_property( sql.select([sql.func.count(comments.c.id)], sql.and_(comments.c.media_id == media.c.id, comments.c.publishable == True)).label('comment_count_published'), deferred=True), })
"""Ensure that modifications to the enable_feed prop won't break things. You cannot disable the last feed-enable file of a podcast episode. """ if (not on and self.media and self.media.podcast_id and len([f for f in self.media.files if f.enable_feed]) == 1): raise MediaException, ('Published podcast media requires ' 'at least one file be feed-enabled.') return on mapper(MediaFile, media_files) _media_mapper = mapper(Media, media, properties={ 'status': status_column_property(media.c.status), 'author': composite(Author, media.c.author_name, media.c.author_email), 'rating': composite(Rating, media.c.rating_sum, media.c.rating_votes), 'files': relation(MediaFile, backref='media', order_by=media_files.c.position.asc(), passive_deletes=True), 'tags': relation(Tag, secondary=media_tags, backref='media', collection_class=TagList), 'topics': relation(Topic, secondary=media_topics, backref='media', collection_class=TopicList), 'comments': relation(Comment, secondary=media_comments, backref=backref('media', uselist=False), extension=CommentTypeExtension('media'), single_parent=True, passive_deletes=True), }) # Add comment_count, comment_count_published, ... column properties to Media _media_mapper.add_properties(_properties_dict_from_labels( comment_count_property('comment_count', media_comments), comment_count_property('comment_count_published', media_comments, status_where( comments.c.status, include='publish', exclude='trash' )), comment_count_property('comment_count_unreviewed', media_comments, status_where(
def __init__(cls, name, bases, dct): if "modified" in dct: event.listen(cls,'before_update',update_modified) if "id" not in dct: # the inherited class already has an 'id' column, but that ends # up being ambiguous and thus won't work dct['id'] = cls.id = db.Column(db.Integer, primary_key=True) cls._refs = [] cls.__table_args__ = list(dct.get('__table_args__',[])) # collect indices for foreign-key tables here # Now walk through all our (base) classes. # This is necessary to collect ObjectRef entries in subclasses seen = set() _alias = cls._alias for ccls in cls.__mro__: for k,v in ccls.__dict__.items(): if k == "_alias": # merge _alias content for kk,vv in v.items(): _alias.setdefault(kk,vv) continue if k.startswith('_'): continue if k in seen: continue seen.add(k) if ObjectRef is not None and isinstance(v,ObjectRef): if v.typ is None: ## any table from .objtyp import ObjType ## Create a new composite. if v.declared_attr: col_typ = declared_attr((lambda k,v: lambda cls: Column(k+'_typ_id',db.Integer, db.ForeignKey(ObjType.id),nullable=v.nullable, doc=v.doc, unique=v.unique))(k,v)) col_id = declared_attr((lambda k,v: lambda cls: Column(k+'_id',db.Integer, nullable=v.nullable))(k,v)) else: col_typ = db.Column(k+'_typ_id',db.Integer, db.ForeignKey(ObjType.id),nullable=v.nullable, doc=v.doc, unique=v.unique) col_id = db.Column(k+'_id',db.Integer, nullable=v.nullable) setattr(cls,k+"_typ_id", col_typ) setattr(cls,k+"_id", col_id) if v.declared_attr: setattr(cls,k, declared_attr((lambda col_typ,col_id: lambda cls: composite(ObjectRef, col_typ,col_id, deferred=True))(col_typ,col_id))) else: setattr(cls,k, composite(ObjRefComposer, col_typ,col_id, deferred=True)) _refs.append((cls,k)) cls.__table_args__.append(Index("i_%s_%s"%(name,k),col_typ,col_id)) else: ## specific table rem = {'lazy': v.lazy} if v.backref: rem['back_populates'] = v.backref if isinstance(v.typ,(int,long)): v.typ = ObjType.get_mod(v.typ) v.typ_id = v.typ.id elif isinstance(v.typ,string_types): if v.typ == "self": col_typ = db.Column(k+'_id',db.Integer, db.ForeignKey(cls.__tablename__+'.id'),nullable=v.nullable, doc=v.doc, unique=v.unique) col_ref = db.relationship(cls, remote_side=[cls.id], foreign_keys=(col_typ,), **rem) setattr(cls,k+"_id", col_typ) setattr(cls,k, col_ref) cls._refs.append((cls,k)) cls.__table_args__.append(Index("i_%s_%s"%(name,k),col_typ)) if v.backref: setattr(cls,v.backref, db.relationship(cls, primaryjoin = col_typ==cls.id, back_populates=k, uselist=not v.unique)) continue else: v.typ = ObjType.q.get_by(path=v.typ).mod v.typ_id = v.typ.id else: v.typ_id = v.typ.id rem['remote_side'] = v.typ.__name__+'.id' if v.declared_attr: col_typ = declared_attr((lambda k,v: lambda cls: Column(k+'_id',db.Integer, db.ForeignKey(v.typ_id),nullable=v.nullable, doc=v.doc, unique=v.unique))(k,v)) col_ref = declared_attr((lambda k,v,r: lambda cls: db.relationship(v.typ, primaryjoin = col_typ==v.typ_id, **r))(k,v,rem)) else: col_typ = db.Column(k+'_id',db.Integer, db.ForeignKey(v.typ_id),nullable=v.nullable, doc=v.doc, unique=v.unique) col_ref = db.relationship(v.typ, primaryjoin = col_typ==v.typ_id, **rem) setattr(cls,k+"_id", col_typ) setattr(cls,k, col_ref) v.typ._refs.append((cls,k)) cls.__table_args__.append(Index("i_%s_%s"%(name,k),col_typ)) if v.backref: if isinstance(v.typ,string_types): setattr(v.typ,v.backref, db.relationship(cls, primaryjoin = "%s_id==%s" % (k,v.typ_id), back_populates=k)) else: setattr(v.typ,v.backref, db.relationship(cls, primaryjoin = col_typ==v.typ.id, back_populates=k, uselist=not v.unique)) elif k == 'modified': event.listen(cls,'before_update',update_modified) _tables.append(cls) cls_ = cls cls.__table_args__ = tuple(cls.__table_args__) class serializer(_serialize_object): cls = cls_ clsname = cls_.__module__+'.'+cls_.__name__ json_adapter(serializer) setup_events(cls) super(ObjectMeta, cls).__init__(name, bases, dct)
query = DBSession.query_property(CommentQuery) def __repr__(self): return '<Comment: %s subject="%s">' % (self.id, self.subject) def __unicode__(self): return self.subject @property def type(self): if self.media_id: return 'media' return None def _get_parent(self): return self.media or None def _set_parent(self, parent): self.media = parent parent = property(_get_parent, _set_parent, None, """ The object this Comment belongs to, provided for convenience mostly. If the parent has not been eagerloaded, a query is executed automatically. """) mapper(Comment, comments, order_by=comments.c.created_on, properties={ 'author': composite(AuthorWithIP, comments.c.author_name, comments.c.author_email, comments.c.author_ip), })
Return the maximum depth recorded over all dives at this site ''' md = 0 for dive in self.dives: if dive.max_depth > md: md = dive.max_depth return md @property def rating(self): ''' Return the average rating for dives at this site. Only considers dives which have a non-zero rating. ''' r = 0 n = 0 for dive in self.dives: if dive.rating: r += dive.rating n += 1 return r / n if n > 0 else 0 def __repr__(self): return '<DiveSite: %s>' % self.site # Dive Site Mapper mapper(DiveSite, tables.sites, properties={ 'dives': relationship(Dive, backref=backref('dive_site', lazy='join')), 'latlng': composite(LatLng, tables.sites.c.lat, tables.sites.c.lon) })
query = DBSession.query_property() _thumb_dir = 'podcasts' def __repr__(self): return '<Podcast: %s>' % self.slug @validates('slug') def validate_slug(self, key, slug): return slugify(slug) mapper(Podcast, podcasts, order_by=podcasts.c.title, extension=events.MapperObserver(events.Podcast), properties={ 'author': composite(Author, podcasts.c.author_name, podcasts.c.author_email), 'media': dynamic_loader(Media, backref='podcast', query_class=MediaQuery, passive_deletes=True), 'media_count': column_property( sql.select( [sql.func.count(media.c.id)], media.c.podcast_id == podcasts.c.id, ).label('media_count'), deferred=True ), 'media_count_published': column_property( sql.select( [sql.func.count(media.c.id)], sql.and_(
def MarkdownColumn(name, deferred=False, group=None, **kwargs): return composite(MarkdownComposite, Column(name + '_text', UnicodeText, **kwargs), Column(name + '_html', UnicodeText, **kwargs), deferred=deferred, group=group or name )
def address(cls): return composite(Address, cls.addr_name, cls.addr_addr1, cls.addr_addr2, cls.addr_addr3, cls.addr_addr4, cls.addr_email, cls.addr_fax, cls.addr_phone)
# so that its other uses throughout the code make more sense. _thumb_dir = 'podcasts' def __repr__(self): return '<Podcast: %r>' % self.slug @validates('slug') def validate_slug(self, key, slug): return slugify(slug) mapper(Podcast, podcasts, order_by=podcasts.c.title, extension=events.MapperObserver(events.Podcast), properties={ 'author': composite(Author, podcasts.c.author_name, podcasts.c.author_email, doc="""An instance of :class:`mediadrop.model.authors.Author`. Although not actually a relation, it is implemented as if it were. This was decision was made to make it easier to integrate with :class:`mediadrop.model.auth.User` down the road."""), 'media': dynamic_loader(Media, backref='podcast', query_class=MediaQuery, passive_deletes=True, doc=\ """A query pre-filtered to media published under this podcast. Returns :class:`mediadrop.model.media.MediaQuery`."""), 'media_count': column_property( sql.select( [sql.func.count(media.c.id)], media.c.podcast_id == podcasts.c.id, ).label('media_count'), deferred=True,