def setUp(self):
if not sqlalchemy:
self.skipTest("'sqlalchemy' is not available")
# Create DB and map objects
self.metadata = MetaData()
self.engine = create_engine("sqlite:///:memory:", echo=False)
Session = sessionmaker(bind=self.engine)
self.session = Session()
self.tables = {}
self.tables["users"] = Table(
"users", self.metadata, Column("id", Integer, primary_key=True), Column("name", String(64))
)
self.tables["addresses"] = Table(
"addresses",
self.metadata,
Column("id", Integer, primary_key=True),
Column("user_id", Integer, ForeignKey("users.id")),
Column("email_address", String(128)),
)
self.tables["lazy_loaded"] = Table(
"lazy_loaded",
self.metadata,
Column("id", Integer, primary_key=True),
Column("user_id", Integer, ForeignKey("users.id")),
)
self.tables["another_lazy_loaded"] = Table(
"another_lazy_loaded",
self.metadata,
Column("id", Integer, primary_key=True),
Column("user_id", Integer, ForeignKey("users.id")),
)
self.mappers = {}
self.mappers["user"] = mapper(
User,
self.tables["users"],
properties={
"addresses": relation(Address, backref="user", lazy=False),
"lazy_loaded": relation(LazyLoaded, lazy=True),
"another_lazy_loaded": relation(AnotherLazyLoaded, lazy=True),
},
)
self.mappers["addresses"] = mapper(Address, self.tables["addresses"])
self.mappers["lazy_loaded"] = mapper(LazyLoaded, self.tables["lazy_loaded"])
self.mappers["another_lazy_loaded"] = mapper(AnotherLazyLoaded, self.tables["another_lazy_loaded"])
self.metadata.create_all(self.engine)
pyamf.register_class(User, "server.User")
pyamf.register_class(Address, "server.Address")
pyamf.register_class(LazyLoaded, "server.LazyLoaded")
def orm_load_baseordereddataset(man):
man.baseordereddataset_table = Table('baseordereddataset', man.metadata,
Column('id', Integer, primary_key=True),
Column('created', DateTime),
Column('label', String(50), nullable=False, unique=True),
Column('type', String(30), nullable=False))
man.ordereditems_table = Table('ordereddata_items', man.metadata,
Column('dataset_id', Integer, ForeignKey('baseordereddataset.id'),
primary_key=True),
Column('item_id', Integer, ForeignKey('basedata.basedata_id'),
primary_key=True),
Column('index', Integer, nullable=False)
)
man.metadata.create_all()
mapper(BaseOrderedDataSet, man.baseordereddataset_table,
polymorphic_on=man.baseordereddataset_table.c.type, polymorphic_identity='base_ordered_dataset',
properties={'data_items': relation(OrderedDataSetItem,
backref='ordered_datasets_items',
cascade='all, delete-orphan',
collection_class=column_mapped_collection(man.ordereditems_table.c.index))
}
)
mapper(OrderedDataSetItem, man.ordereditems_table, properties={
'item': relation(BaseData, lazy='joined', backref='dataitem')
})
def _setup_mappers(self, tables, mappers):
"""Map the database Tables to SQLAlchemy Mapper objects
"""
standalone_table_tuple_ls = [
("snps", SNPs),
("call_method", CallMethod),
("readme", README),
("accession", Accession),
]
for table_name, table_class in standalone_table_tuple_ls:
mappers[table_name] = mapper(table_class, tables[table_name])
mappers["snpset"] = mapper(
SNPset,
tables["snpset"],
properties={"snps": relation(SNPs, secondary=tables["snps2snpset"], backref="snpset")},
)
mappers["snps2snpset"] = mapper(
SNPs2SNPset, tables["snps2snpset"], properties={"snps": relation(SNPs), "snpset": relation(SNPset)}
)
mappers["calls"] = mapper(
Calls,
tables["calls"],
properties={"snps": relation(SNPs), "call_method": relation(CallMethod), "accession": relation(Accession)},
)
mappers["snps_ab_allele_mapping"] = mapper(
SNPsABAlleleMapping,
tables["snps_ab_allele_mapping"],
properties={"snps": relation(SNPs, backref="snps_ab_allele_mapping"), "readme": relation(README)},
)
def initialize_mapper():
orm.mapper(Content, content,
polymorphic_on=content.c.object_type,
polymorphic_identity='content',
properties = {
'children': orm.relation(
Content,
backref=orm.backref(
'parent',
remote_side=[content.c.content_id])),
'relations': orm.relation(
Relation,
cascade="all, delete-orphan",
primaryjoin=content.c.content_id==relations.c.source_id,
backref=orm.backref("source"))})
orm.mapper(Relation, relations,
properties = {
'target': orm.relation(
Content, uselist=False,
primaryjoin=content.c.content_id==relations.c.target_id)})
orm.mapper(File, files,
polymorphic_on=files.c.type,
polymorphic_identity='db-file')
def initModels():
"""Initialize timebot DB tables and mappers"""
engine = db.getEngine()
meta = db.getMeta()
session = db.getSession()
tb_user = Table(
'tb_user', meta,
Column('id', Integer, primary_key=True, autoincrement=True),
Column('company_id', None, ForeignKey('tb_company.id'), nullable=True),
Column('jid', Unicode(50), unique=True, nullable=False),
Column('name', Unicode(50)),
Column('rate', Integer))
tb_worktime = Table(
'tb_time', meta,
Column('id', Integer, primary_key=True),
Column('user_id', None, ForeignKey('tb_user.id'), nullable=False),
Column('start', DateTime, default=datetime.now),
Column('stop', DateTime, nullable=True))
tb_company = Table(
'tb_company', meta,
Column('id', Integer, primary_key=True),
Column('name', Unicode(50), nullable=True))
meta.create_all()
mapper(TUser, tb_user, properties=dict(
worktime=relation(TWorktime),
company=relation(TCompany)))
mapper(TWorktime, tb_worktime, properties=dict(
user=relation(TUser)))
mapper(TCompany, tb_company, properties=dict(
users=relation(TUser)))
def versions_properties(item_class, change_class, versions_table):
props = {
"change": relation(change_class, uselist=False),
"head": relation(item_class, uselist=False)
}
# Notes:
# - domain.AttachedFile is the only versionable type that is
# not a ParliamentaryItem.
# - !+IVersionable(mr, jul-2011) an AttachedFile does not have
# attached_files; but, this violates the meaning of IVersionable?
# Or, the ability to have attached_files should be independent of
# being versionable? IMayAttachFiles
if item_class is not domain.AttachedFile:
props["attached_files"] = relation(domain.AttachedFileVersion,
primaryjoin=rdb.and_(
versions_table.c.content_id ==
schema.attached_file_versions.c.item_id,
versions_table.c.version_id ==
schema.attached_file_versions.c.file_version_id
),
foreign_keys=[
schema.attached_file_versions.c.item_id,
schema.attached_file_versions.c.file_version_id
]
)
return props
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 create_tables():
"""Create tables filled with test data."""
occupations_table = Table('occupations', metadata,
Column('id', Integer, primary_key=True),
Column('name', String(20)))
users_table = Table('users', metadata,
Column('id', Integer, primary_key=True),
Column('name', String(20)),
Column('occupation_id', Integer, ForeignKey("occupations.id")))
addresses_table = Table('addresses', metadata,
Column('id', Integer, primary_key=True),
Column('user_id', Integer, ForeignKey("users.id")),
Column('street', String(50)),
Column('city', String(40)))
mapper(Occupation, occupations_table)
mapper(User, users_table, properties={
'occupation' : relation(Occupation, lazy=False),
'addresses': relation(Address, backref='user', lazy=False)})
mapper(Address, addresses_table)
try:
metadata.create_all()
except Exception, error:
# workaround for a problem with PySqlite < 2.6 and SQLAlchemy < 0.5
if 'Cannot operate on a closed cursor' in str(error):
metadata.create_all(checkfirst=False)
else:
raise
def init_model(engine):
"""Call me before using any of the tables or classes in the model"""
global prefix_table
prefix_table = schema.Table('prefix', meta.metadata,
schema.Column('id', types.Integer,
schema.Sequence('prefix_id_seq'), primary_key=True),
schema.Column('prefix', types.Text())
)
global users_table
users_table = schema.Table('users', meta.metadata,
schema.Column('id', types.Integer,
schema.Sequence('users_id_seq'), primary_key=True),
schema.Column('name', types.Text()),
schema.Column('password', types.Text()),
schema.Column('real_name', types.Text())
)
global users_prefix_access
users_prefix_access = schema.Table('user_prefix_access', meta.metadata,
schema.Column('user_id', types.Integer, schema.ForeignKey('users.id'), primary_key=True),
schema.Column('prefix_id', types.Integer, schema.ForeignKey('prefix.id'), primary_key=True),
schema.Column('write_access', types.Integer)
)
orm.mapper(Users, users_table, properties = { 'base':orm.relation(UsersPrefixAssociation) })
orm.mapper(UsersPrefixAssociation, users_prefix_access, properties = { 'prefix':orm.relation(Prefix) })
orm.mapper(Prefix, prefix_table)
meta.Session.configure(bind=engine)
meta.engine = engine
def test_pending_expunge(self):
class Order(_fixtures.Base):
pass
class Item(_fixtures.Base):
pass
class Attribute(_fixtures.Base):
pass
mapper(Attribute, attributes)
mapper(Item, items, properties=dict(
attributes=relation(Attribute, cascade="all,delete-orphan", backref="item")
))
mapper(Order, orders, properties=dict(
items=relation(Item, cascade="all,delete-orphan", backref="order")
))
s = create_session()
order = Order(name="order1")
s.add(order)
attr = Attribute(name="attr1")
item = Item(name="item1", attributes=[attr])
order.items.append(item)
order.items.remove(item)
assert item not in s
assert attr not in s
s.flush()
assert orders.count().scalar() == 1
assert items.count().scalar() == 0
assert attributes.count().scalar() == 0
def setup_orm():
tables = meta.metadata.tables
orm.mapper(Language, tables['languages'])
orm.mapper(I18nText, tables['i18n_texts'],
properties={
'versions': relation(I18nTextVersion,
order_by=tables['i18n_texts_versions'].c.language_id.asc())
})
orm.mapper(I18nTextVersion, tables['i18n_texts_versions'],
properties={ 'language': relation(Language) })
# LanguageText is deprecated until it uses I18nText
orm.mapper(LanguageText,
tables['language_texts'],
properties={
'language': relation(Language,
backref=backref('texts',
order_by=tables['language_texts'].c.id.asc(),
cascade='all, delete-orphan'))})
orm.mapper(Country,
tables['countries'],
properties={
'language': relation(Language,
backref=backref('countries',
cascade='all, delete-orphan',
order_by=tables['countries'].c.id.asc()))})
def reload_mapper(metadata, now):
"""<comment-ja>
Machine(Model)のマッパーをリロードします。
@param metadata: リロードしたいMetaData
@type metadata: sqlalchemy.schema.MetaData
@param now: now
@type now: Datatime
</comment-ja>
<comment-en>
TODO: English Comment
</comment-en>
"""
t_machine = get_machine_table(metadata, now)
t_machine_tag = metadata.tables['machine2tag']
t_user = metadata.tables['user']
mapper(Machine, t_machine, properties={
'children' : relation(Machine,
backref=backref('parent',
remote_side=[t_machine.c.id])),
'notebook' : relation(karesansui.db.model.notebook.Notebook),
'created_user' : relation(karesansui.db.model.user.User,
primaryjoin=t_machine.c.created_user_id==t_user.c.id),
'modified_user' : relation(karesansui.db.model.user.User,
primaryjoin=t_machine.c.modified_user_id==t_user.c.id),
'tags' : relation(karesansui.db.model.tag.Tag,
secondary=t_machine_tag,
backref="machine"),
})
def reload_mapper(metadata, now):
"""<comment-ja>
Machine2Jobgroup(Model)のマッパーをリロードします。
@param metadata: リロードしたいMetaData
@type metadata: sqlalchemy.schema.MetaData
@param now: now
@type now: Datatime
</comment-ja>
<comment-en>
TODO: English Comment
</comment-en>
"""
t_machine2jobgroup = get_machine2jobgroup_table(metadata, now)
t_machine = metadata.tables["machine"]
t_user = metadata.tables["user"]
mapper(Machine2Jobgroup, t_machine2jobgroup, properties={
'created_user' : relation(karesansui.db.model.user.User,
primaryjoin=t_machine2jobgroup.c.created_user_id==t_user.c.id),
'modified_user' : relation(karesansui.db.model.user.User,
primaryjoin=t_machine2jobgroup.c.modified_user_id==t_user.c.id),
'machine' : relation(karesansui.db.model.machine.Machine,
primaryjoin=t_machine2jobgroup.c.machine_id==t_machine.c.id,
),
})
def testone(self):
"""
Tests eager load of a many-to-one attached to a one-to-many. this
testcase illustrated the bug, which is that when the single Company is
loaded, no further processing of the rows occurred in order to load
the Company's second Address object.
"""
mapper(Address, addresses)
mapper(Company, companies, properties={"addresses": relation(Address, lazy=False)})
mapper(Invoice, invoices, properties={"company": relation(Company, lazy=False)})
a1 = Address(address="a1 address")
a2 = Address(address="a2 address")
c1 = Company(company_name="company 1", addresses=[a1, a2])
i1 = Invoice(date=datetime.datetime.now(), company=c1)
session = create_session()
session.add(i1)
session.flush()
company_id = c1.company_id
invoice_id = i1.invoice_id
session.expunge_all()
c = session.query(Company).get(company_id)
session.expunge_all()
i = session.query(Invoice).get(invoice_id)
eq_(c, i.company)
def make_tables( me):
t1 = Table('table1', me.meta,
Column('name', Text, ),
Column('id', Integer, primary_key=True),
Column('t2_id', Integer,
ForeignKey('table2.id',)
)
)
t2 = Table('table2', me.meta,
Column('name', Text, ),
Column('id', Integer, primary_key=True),
Column('t1_id', Integer,
ForeignKey('table1.id',
use_alter=True,
name='zt2id_fk'
)
)
)
me.meta.create_all()
mapper( A, t1, properties={
'link': relation( B,
primaryjoin= t1.c.t2_id==t2.c.id,
)
})
mapper( B, t2, properties={
'link': relation( A,
primaryjoin= t2.c.t1_id==t1.c.id,
post_update=True
)
})
def setup_orm():
tables = meta.metadata.tables
columns = tables['group_mailing_list_messages'].c
orm.mapper(GroupMailingListMessage,
tables['group_mailing_list_messages'],
inherits=ContentItem,
polymorphic_identity='mailing_list_message',
polymorphic_on=tables['content_items'].c.content_type,
properties = {
'reply_to': relation(GroupMailingListMessage,
backref=backref('replies'),
foreign_keys=(columns.reply_to_message_machine_id),
primaryjoin=columns.id == columns.reply_to_message_machine_id,
remote_side=(columns.id)),
'thread': relation(GroupMailingListMessage,
post_update=True,
order_by=[asc(columns.sent)],
backref=backref('posts'),
foreign_keys=(columns.thread_message_machine_id),
primaryjoin=columns.id == columns.thread_message_machine_id,
remote_side=(columns.id)),
'author': relation(User,
backref=backref('messages')),
'group': relation(Group,
primaryjoin=(columns.group_id == tables['groups'].c.id)),
'attachments': synonym("files")
})
def test_bidirectional(self):
"""tests a many-to-many backrefs"""
Place.mapper = mapper(Place, place)
Transition.mapper = mapper(Transition, transition, properties = dict(
inputs = relation(Place.mapper, place_output, lazy=True, backref='inputs'),
outputs = relation(Place.mapper, place_input, lazy=True, backref='outputs'),
)
)
t1 = Transition('transition1')
t2 = Transition('transition2')
t3 = Transition('transition3')
p1 = Place('place1')
p2 = Place('place2')
p3 = Place('place3')
t1.inputs.append(p1)
t1.inputs.append(p2)
t1.outputs.append(p3)
t2.inputs.append(p1)
p2.inputs.append(t2)
p3.inputs.append(t2)
p1.outputs.append(t1)
sess = create_session()
sess.add_all((t1, t2, t3,p1, p2, p3))
sess.flush()
self.assert_result([t1], Transition, {'outputs': (Place, [{'name':'place3'}, {'name':'place1'}])})
self.assert_result([p2], Place, {'inputs': (Transition, [{'name':'transition1'},{'name':'transition2'}])})
def test_double(self):
"""test that a mapper can have two eager relations to the same table, via
two different association tables. aliases are required."""
Place.mapper = mapper(Place, place, properties = {
'thingies':relation(mapper(PlaceThingy, place_thingy), lazy=False)
})
Transition.mapper = mapper(Transition, transition, properties = dict(
inputs = relation(Place.mapper, place_output, lazy=False),
outputs = relation(Place.mapper, place_input, lazy=False),
)
)
tran = Transition('transition1')
tran.inputs.append(Place('place1'))
tran.outputs.append(Place('place2'))
tran.outputs.append(Place('place3'))
sess = create_session()
sess.add(tran)
sess.flush()
sess.expunge_all()
r = sess.query(Transition).all()
self.assert_unordered_result(r, Transition,
{'name': 'transition1',
'inputs': (Place, [{'name':'place1'}]),
'outputs': (Place, [{'name':'place2'}, {'name':'place3'}])
})
def initialize_sql(engine):
"""Called by the app on startup to setup bindings to the DB"""
DBSession.configure(bind=engine)
Base.metadata.bind = engine
# only if we are on sqlite do we have this relation
if 'sqlite' in str(DBSession.bind):
if not hasattr(SqliteBmarkFT, 'bmark'):
Bmark.fulltext = relation(SqliteBmarkFT,
backref='bmark',
uselist=False,
cascade="all, delete, delete-orphan",
)
if not hasattr(SqliteContentFT, 'readable'):
Readable.fulltext = relation(SqliteContentFT,
backref='readable',
uselist=False,
cascade="all, delete, delete-orphan",
)
# this is purely to make queries easier. If I've searched the content,
# I want to get back to the hashed->bmark as quickly as possible. Since
# there's only one fulltext result for each hashed anyway, it's ok to
# join it directly without going through the Readable table object
if not hasattr(SqliteContentFT, 'hashed'):
Hashed.fulltext = relation(SqliteContentFT,
backref='hashed',
uselist=False,
primaryjoin=Hashed.hash_id == SqliteContentFT.hash_id,
foreign_keys=[SqliteContentFT.hash_id],
cascade="all, delete, delete-orphan",
)
def test_one(self):
p_m = mapper(Part, parts)
mapper(InheritedPart, inherited_part, properties=dict(
part=relation(Part, lazy=False)))
d_m = mapper(Design, design, properties=dict(
inheritedParts=relation(InheritedPart,
cascade="all, delete-orphan",
backref="design")))
mapper(DesignType, design_types)
d_m.add_property(
"type", relation(DesignType, lazy=False, backref="designs"))
p_m.add_property(
"design", relation(
Design, lazy=False,
backref=backref("parts", cascade="all, delete-orphan")))
d = Design()
sess = create_session()
sess.add(d)
sess.flush()
sess.expunge_all()
x = sess.query(Design).get(1)
x.inheritedParts
def setup_mappers(cls):
mapper(Extra, extra)
mapper(Pref, prefs, properties=dict(
extra = relation(Extra, cascade="all, delete")
))
mapper(User, users, properties = dict(
pref = relation(Pref, lazy=False, cascade="all, delete-orphan", single_parent=True )
))
def createMappers(self):
orm.clear_mappers()
orm.mapper(models.User, self.users_table, properties={
'emails': orm.relation(models.Email, lazy=False),
'phone_numbers': orm.relation(models.PhoneNumber, lazy=True)})
orm.mapper(models.Email, self.emails_table)
orm.mapper(models.PhoneNumber, self.phone_numbers_table)
def setup_mappers(cls):
mapper(T1, t1, properties={
't2':relation(T2, primaryjoin=t1.c.t2id == t2.c.id)})
mapper(T2, t2, properties={
't1':relation(T1, primaryjoin=t2.c.t1id == t1.c.id)})
mapper(T3, t3, properties={
't1':relation(T1),
't2':relation(T2)})
def init_model():
engine = meta.engine
bb_post_table = sa.Table('bb_post', meta.metadata,
sa.Column('id', types.Integer, primary_key=True),
sa.Column('title', types.String(255)),
sa.Column('slug', types.String(255)),
sa.Column('body', types.Text),
sa.Column('userId', types.Integer, sa.ForeignKey('bb_user.id')),
sa.Column('posted', types.DateTime, onupdate=datetime.datetime.now),
sa.Column('edited', types.DateTime))
orm.mapper(Post, bb_post_table, \
properties={'user':orm.relation(User), \
'comments':orm.relation(Comment)})
bb_tag_table = sa.Table('bb_tag', meta.metadata,
sa.Column('id', types.Integer, primary_key=True),
sa.Column('name', types.String(255)),
sa.Column('slug', types.String(255)))
orm.mapper(Tag, bb_tag_table)
bb_post_tag_table = sa.Table('bb_post_tag', meta.metadata,
sa.Column('id', types.Integer, primary_key=True),
sa.Column('postId', types.Integer, sa.ForeignKey('bb_post.id')),
sa.Column('tagId', types.Integer, sa.ForeignKey('bb_tag.id')))
bb_comment_table = sa.Table('bb_comment_table', meta.metadata,
sa.Column('id', types.Integer, primary_key=True),
sa.Column('name', types.String(60)),
sa.Column('email', types.String(100)),
sa.Column('url', types.String(255)),
sa.Column('body', types.Text),
sa.Column('postId', types.Integer, sa.ForeignKey('bb_post.id')),
sa.Column('userId', types.Integer, sa.ForeignKey('bb_user.id')),
sa.Column('posted', types.DateTime, onupdate=datetime.datetime.now))
orm.mapper(Comment, bb_comment_table, \
properties={'post':orm.relation(Post)})
bb_user_table = sa.Table('bb_user', meta.metadata,
sa.Column('id', types.Integer, primary_key=True),
sa.Column('username', types.String(255)),
sa.Column('password', types.String(64)),
sa.Column('nickname', types.String(255)),
sa.Column('roleId', types.Integer, sa.ForeignKey('bb_role.id')),
sa.Column('status', types.String(30)))
orm.mapper(User, bb_user_table, properties={'role':orm.relation(Role)})
bb_role_table = sa.Table('bb_role', meta.metadata,
sa.Column('id', types.Integer, primary_key=True),
sa.Column('name', types.String(60)))
orm.mapper(Role, bb_role_table)
bb_resource_table = sa.Table('bb_resource', meta.metadata,
sa.Column('id', types.Integer, primary_key=True),
sa.Column('name', types.String(90)))
orm.mapper(Resource, bb_resource_table)
meta.Session.configure(bind=engine)
def changes_properties(item_class, change_tbl):
return {
"user": relation(domain.User,
primaryjoin=(change_tbl.c.user_id == schema.users.c.user_id),
uselist=False,
lazy=True
),
"head": relation(item_class, uselist=False)
}
def test_error(self):
mapper(Place, place, properties={
'transitions':relation(Transition, secondary=place_input, backref='places')
})
mapper(Transition, transition, properties={
'places':relation(Place, secondary=place_input, backref='transitions')
})
assert_raises_message(sa.exc.ArgumentError, "Error creating backref",
sa.orm.compile_mappers)
def init_model(bind):
global engine,Session
"""Call me before using any of the tables or classes in the model"""
engine = bind
Session = orm.scoped_session(
orm.sessionmaker(autocommit=False, autoflush=True, bind=bind))
orm.mapper(id_AES, aes_table, properties={'yubikey': orm.relation(Key)} )
orm.mapper(Key, key_table, properties={'yubi_aes': orm.relation(id_AES), 'api': orm.relation(API)} )
orm.mapper(API, api_table)
def testtwo(self):
"""The original testcase that includes various complicating factors"""
mapper(Phone, phone_numbers)
mapper(Address, addresses, properties={
'phones': relation(Phone, lazy=False, backref='address',
order_by=phone_numbers.c.phone_id)})
mapper(Company, companies, properties={
'addresses': relation(Address, lazy=False, backref='company',
order_by=addresses.c.address_id)})
mapper(Item, items)
mapper(Invoice, invoices, properties={
'items': relation(Item, lazy=False, backref='invoice',
order_by=items.c.item_id),
'company': relation(Company, lazy=False, backref='invoices')})
c1 = Company(company_name='company 1', addresses=[
Address(address='a1 address',
phones=[Phone(type='home', number='1111'),
Phone(type='work', number='22222')]),
Address(address='a2 address',
phones=[Phone(type='home', number='3333'),
Phone(type='work', number='44444')])
])
session = create_session()
session.add(c1)
session.flush()
company_id = c1.company_id
session.expunge_all()
a = session.query(Company).get(company_id)
# set up an invoice
i1 = Invoice(date=datetime.datetime.now(), company=a)
item1 = Item(code='aaaa', qty=1, invoice=i1)
item2 = Item(code='bbbb', qty=2, invoice=i1)
item3 = Item(code='cccc', qty=3, invoice=i1)
session.flush()
invoice_id = i1.invoice_id
session.expunge_all()
c = session.query(Company).get(company_id)
session.expunge_all()
i = session.query(Invoice).get(invoice_id)
eq_(c, i.company)
def orm_load_floatdelta(man):
man.floatdelta_table = Table('floatdelta', man.metadata,
Column('basedata_id', Integer, ForeignKey('basedata.basedata_id'), primary_key=True),
Column('channel_1_id', Integer, ForeignKey('channel.id')),
Column('channel_2_id', Integer, ForeignKey('channel.id')),
Column('delta', Float))
#man.metadata.create_all()
mapper(FloatDelta, man.floatdelta_table, inherits=BaseData, polymorphic_identity='floatdelta',
properties={'channel_1': relation(Channel, primaryjoin=man.floatdelta_table.c.channel_1_id==man.channel_table.c.id),
'channel_2': relation(Channel, primaryjoin=man.floatdelta_table.c.channel_2_id==man.channel_table.c.id)})
def setup_mappers(cls):
mapper(Address, addresses)
mapper(User, users, properties = dict(
addresses = relation(Address, cascade="all, delete-orphan", backref="user"),
orders = relation(
mapper(Order, orders), cascade="all, delete-orphan")
))
mapper(Dingaling,dingalings, properties={
'address':relation(Address)
})
Column("create_time", DateTime, default=now),
Column("update_time", DateTime, default=now, onupdate=now),
Column("name", TrimmedString(255), index=True, unique=True),
Column("description", TEXT),
Column("deleted", Boolean, index=True, default=False))
Tag.table = Table("tag", metadata,
Column("id", Integer, primary_key=True),
Column("type", Integer),
Column("parent_id", Integer, ForeignKey("tag.id")),
Column("name", TrimmedString(255)),
UniqueConstraint("name"))
# With the tables defined we can define the mappers and setup the relationships between the model objects.
mapper(User, User.table,
properties=dict(active_repositories=relation(Repository, primaryjoin=((Repository.table.c.user_id == User.table.c.id) & (not_(Repository.table.c.deleted))), order_by=(Repository.table.c.name)),
galaxy_sessions=relation(GalaxySession, order_by=desc(GalaxySession.table.c.update_time)),
api_keys=relation(APIKeys, backref="user", order_by=desc(APIKeys.table.c.create_time))))
mapper(PasswordResetToken, PasswordResetToken.table,
properties=dict(user=relation(User, backref="reset_tokens")))
mapper(APIKeys, APIKeys.table, properties={})
mapper(Group, Group.table,
properties=dict(users=relation(UserGroupAssociation)))
mapper(Role, Role.table,
properties=dict(
repositories=relation(RepositoryRoleAssociation,
primaryjoin=((Role.table.c.id == RepositoryRoleAssociation.table.c.role_id) & (RepositoryRoleAssociation.table.c.repository_id == Repository.table.c.id))),
def define_harvester_tables():
global harvest_source_table
global harvest_job_table
global harvest_object_table
global harvest_object_extra_table
global harvest_gather_error_table
global harvest_object_error_table
global harvest_log_table
harvest_source_table = Table(
'harvest_source',
metadata,
Column('id', types.UnicodeText, primary_key=True, default=make_uuid),
Column('url', types.UnicodeText, nullable=False),
Column('title', types.UnicodeText, default=u''),
Column('description', types.UnicodeText, default=u''),
Column('config', types.UnicodeText, default=u''),
Column('created', types.DateTime, default=datetime.datetime.utcnow),
Column('type', types.UnicodeText, nullable=False),
Column('active', types.Boolean, default=True),
Column('user_id', types.UnicodeText, default=u''),
Column('publisher_id', types.UnicodeText, default=u''),
Column('frequency', types.UnicodeText, default=u'MANUAL'),
Column('next_run', types.DateTime),
)
# Was harvesting_job
harvest_job_table = Table(
'harvest_job',
metadata,
Column('id', types.UnicodeText, primary_key=True, default=make_uuid),
Column('created', types.DateTime, default=datetime.datetime.utcnow),
Column('gather_started', types.DateTime),
Column('gather_finished', types.DateTime),
Column('finished', types.DateTime),
Column('source_id', types.UnicodeText,
ForeignKey('harvest_source.id')),
# status: New, Running, Finished
Column('status', types.UnicodeText, default=u'New', nullable=False),
)
# A harvest_object contains a representation of one dataset during a
# particular harvest
harvest_object_table = Table(
'harvest_object',
metadata,
Column('id', types.UnicodeText, primary_key=True, default=make_uuid),
# The guid is the 'identity' of the dataset, according to the source.
# So if you reharvest it, then the harvester knows which dataset to
# update because of this identity. The identity needs to be unique
# within this CKAN.
Column('guid', types.UnicodeText, default=u''),
# When you harvest a dataset multiple times, only the latest
# successfully imported harvest_object should be flagged 'current'.
# The import_stage usually reads and writes it.
Column('current', types.Boolean, default=False),
Column('gathered', types.DateTime, default=datetime.datetime.utcnow),
Column('fetch_started', types.DateTime),
Column('content', types.UnicodeText, nullable=True),
Column('fetch_finished', types.DateTime),
Column('import_started', types.DateTime),
Column('import_finished', types.DateTime),
# state: WAITING, FETCH, IMPORT, COMPLETE, ERROR
Column('state', types.UnicodeText, default=u'WAITING'),
Column('metadata_modified_date', types.DateTime),
Column('retry_times', types.Integer, default=0),
Column('harvest_job_id', types.UnicodeText,
ForeignKey('harvest_job.id')),
Column('harvest_source_id', types.UnicodeText,
ForeignKey('harvest_source.id')),
Column('package_id',
types.UnicodeText,
ForeignKey('package.id', deferrable=True),
nullable=True),
# report_status: 'added', 'updated', 'not modified', 'deleted', 'errored'
Column('report_status', types.UnicodeText, nullable=True),
Index('harvest_job_id_idx', 'harvest_job_id'),
)
# New table
harvest_object_extra_table = Table(
'harvest_object_extra',
metadata,
Column('id', types.UnicodeText, primary_key=True, default=make_uuid),
Column('harvest_object_id', types.UnicodeText,
ForeignKey('harvest_object.id')),
Column('key', types.UnicodeText),
Column('value', types.UnicodeText),
)
# New table
harvest_gather_error_table = Table(
'harvest_gather_error',
metadata,
Column('id', types.UnicodeText, primary_key=True, default=make_uuid),
Column('harvest_job_id', types.UnicodeText,
ForeignKey('harvest_job.id')),
Column('message', types.UnicodeText),
Column('created', types.DateTime, default=datetime.datetime.utcnow),
)
# New table
harvest_object_error_table = Table(
'harvest_object_error',
metadata,
Column('id', types.UnicodeText, primary_key=True, default=make_uuid),
Column('harvest_object_id', types.UnicodeText,
ForeignKey('harvest_object.id')),
Column('message', types.UnicodeText),
Column('stage', types.UnicodeText),
Column('line', types.Integer),
Column('created', types.DateTime, default=datetime.datetime.utcnow),
)
# Harvest Log table
harvest_log_table = Table(
'harvest_log',
metadata,
Column('id', types.UnicodeText, primary_key=True, default=make_uuid),
Column('content', types.UnicodeText, nullable=False),
Column(
'level',
types.Enum('DEBUG',
'INFO',
'WARNING',
'ERROR',
'CRITICAL',
name='log_level')),
Column('created', types.DateTime, default=datetime.datetime.utcnow),
)
mapper(
HarvestSource,
harvest_source_table,
properties={
'jobs':
relation(
HarvestJob,
lazy=True,
backref=u'source',
order_by=harvest_job_table.c.created,
),
},
)
mapper(
HarvestJob,
harvest_job_table,
)
mapper(
HarvestObject,
harvest_object_table,
properties={
'package': relation(
Package,
lazy=True,
backref='harvest_objects',
),
'job': relation(
HarvestJob,
lazy=True,
backref=u'objects',
),
'source': relation(
HarvestSource,
lazy=True,
backref=u'objects',
),
},
)
mapper(
HarvestGatherError,
harvest_gather_error_table,
properties={
'job': relation(HarvestJob, backref='gather_errors'),
},
)
mapper(
HarvestObjectError,
harvest_object_error_table,
properties={
'object':
relation(HarvestObject,
backref=backref('errors', cascade='all,delete-orphan')),
},
)
mapper(
HarvestObjectExtra,
harvest_object_extra_table,
properties={
'object':
relation(HarvestObject,
backref=backref('extras', cascade='all,delete-orphan')),
},
)
mapper(
HarvestLog,
harvest_log_table,
)
event.listen(HarvestObject, 'before_insert',
harvest_object_before_insert_listener)
class TVDBSeries(TVDBContainer, Base):
__tablename__ = "tvdb_series"
id = Column(Integer, primary_key=True, autoincrement=False)
lastupdated = Column(Integer)
expired = Column(Boolean)
seriesname = Column(Unicode)
language = Column(Unicode)
rating = Column(Float)
status = Column(Unicode)
runtime = Column(Integer)
airs_time = Column(Unicode)
airs_dayofweek = Column(Unicode)
contentrating = Column(Unicode)
network = Column(Unicode)
overview = Column(Unicode)
imdb_id = Column(String)
zap2it_id = Column(String)
banner = Column(String)
fanart = Column(String)
poster = Column(String)
poster_file = Column(Unicode)
_genre = Column('genre', Unicode)
genre = pipe_list_synonym('_genre')
_firstaired = Column('firstaired', DateTime)
firstaired = text_date_synonym('_firstaired')
episodes = relation('TVDBEpisode',
backref='series',
cascade='all, delete, delete-orphan')
def update(self, tvdb_id=None):
tvdb_id = tvdb_id or self.id
url = get_mirror() + api_key + '/series/%s/%s.xml' % (tvdb_id,
language)
try:
data = requests.get(url).content
except RequestException as e:
raise LookupError('Request failed %s' % url)
result = ElementTree.fromstring(data).find('Series')
if result is not None:
self.update_from_xml(result)
else:
raise LookupError('Could not retrieve information from thetvdb')
def get_poster(self, only_cached=False):
"""Downloads this poster to a local cache and returns the path"""
from flexget.manager import manager
base_dir = os.path.join(manager.config_base, 'userstatic')
if os.path.isfile(os.path.join(base_dir, self.poster_file or '')):
return self.poster_file
elif only_cached:
return
# If we don't already have a local copy, download one.
url = get_mirror('banner') + self.poster
log.debug('Downloading poster %s' % url)
dirname = os.path.join('tvdb', 'posters')
# Create folders if the don't exist
fullpath = os.path.join(base_dir, dirname)
if not os.path.isdir(fullpath):
os.makedirs(fullpath)
filename = os.path.join(dirname, posixpath.basename(self.poster))
thefile = file(os.path.join(base_dir, filename), 'wb')
thefile.write(requests.get(url).content)
self.poster_file = filename
# If we are detached from a session, update the db
if not Session.object_session(self):
with Session() as session:
session.query(TVDBSeries).filter(
TVDBSeries.id == self.id).update(
values={'poster_file': filename})
return filename
def __repr__(self):
return '<TVDBSeries name=%s,tvdb_id=%s>' % (self.seriesname, self.id)
__author__ = 'Jonny Lamb'
__copyright__ = 'Copyright © 2008 Jonny Lamb'
__license__ = 'MIT'
import sqlalchemy as sa
from sqlalchemy import orm
from debexpo.model import meta, OrmObject
from debexpo.model.package_versions import PackageVersion
t_binary_packages = sa.Table(
'binary_packages',
meta.metadata,
sa.Column('id', sa.types.Integer, primary_key=True),
sa.Column('package_version_id', sa.types.Integer,
sa.ForeignKey('package_versions.id')),
sa.Column('arch', sa.types.String(200), nullable=False),
)
class BinaryPackage(OrmObject):
foreign = ['package_version']
orm.mapper(BinaryPackage,
t_binary_packages,
properties={
'package_version':
orm.relation(PackageVersion, backref='binary_packages'),
})
__all__ = ['GroupExtra', 'group_extra_table']
group_extra_table = Table('group_extra', meta.metadata,
Column('id', types.UnicodeText, primary_key=True, default=_types.make_uuid),
Column('group_id', types.UnicodeText, ForeignKey('group.id')),
Column('key', types.UnicodeText),
Column('value', types.UnicodeText),
Column('state', types.UnicodeText, default=core.State.ACTIVE),
)
class GroupExtra(core.StatefulObjectMixin,
domain_object.DomainObject):
pass
meta.mapper(GroupExtra, group_extra_table, properties={
'group': orm.relation(group.Group,
backref=orm.backref('_extras',
collection_class=orm.collections.attribute_mapped_collection(u'key'),
cascade='all, delete, delete-orphan',
),
)
}
)
def _create_extra(key, value):
return GroupExtra(key=str(key), value=value)
group.Group.extras = association_proxy(
'_extras', 'value', creator=_create_extra)
pass
orm.mapper(SoftwareVersion, software_version_table)
orm.mapper(SoftwareFollower, software_follower_table)
orm.mapper(SoftwareReviewDigger, software_review_digger_table
#, properties={
# 'member': orm.relation(Member),
#}
)
orm.mapper(
SoftwareReview,
software_review_table,
properties={
'diggers': orm.relation(SoftwareReviewDigger),
# 'member': orm.relation(Member),
})
class Software(object):
def __init__(self, name=''):
self.name = name
def get_android_apps(self):
return session.query(Software).filter(Software.type == '1')
def get_followers(self, limit=20):
fs = session.query(SoftwareFollower).filter(
SoftwareFollower.software_id == self.id)
return fs
class TableApp(Base):
__tablename__ = 'app'
id = Column(Integer, primary_key=True)
app_id = Column(String(255), unique=True)
title = Column(String(255))
creator = Column(String(255))
creator_id = Column(String(255))
package_name = Column(String(255), unique=True)
version = Column(String(255))
version_code = Column(Integer)
rating = Column(String(255))
promo_text = Column(Text)
ratings_count = Column(Integer)
install_size = Column(Integer)
downloads_count_text = Column(String(255))
permission_id_list = Column(String(255))
permission_num = Column(Integer)
category_name = Column(String(255))
contact_email = Column(String(255))
contact_website = Column(String(255))
recent_changes = Column(String(255))
description = Column(Text)
price_currency = Column(String(255))
created_on = Column(DateTime)
updated_on = Column(DateTime)
category_id = Column(Integer, ForeignKey('category.id'))
category = relation('TableCategory', backref='category')
apks = relation('TableApk',
order_by='TableApk.id',
uselist=True,
backref='app',
secondary=app_apk)
def __init__(self, obj):
self.app_id = obj['appId']
self.title = obj['title']
self.creator = obj['creator']
self.creator_id = obj['creatorId']
self.package_name = obj['packageName']
self.version = obj['version']
self.version_code = obj['versionCode']
self.rating = obj['rating']
self.promo_text = obj['promoText']
self.ratings_count = obj['ratingsCount']
self.install_size = obj['installSize']
self.downloads_count_text = obj['downloadsCountText']
self.permission_id_list = obj['permissionIdList']
self.permission_num = obj['permissionNum']
self.category_name = obj['category']
self.contact_email = obj['contactEmail']
self.contact_website = obj['contactWebsite']
self.recent_changes = obj['recentChanges']
self.description = obj['description']
self.price_currency = obj['priceCurrency']
self.created_on = datetime.utcnow()
self.updated_on = datetime.utcnow()
def __repr__(self):
return '<TableApp: %r>' % self.app_id
def _test_onetomany(self, passive_updates):
mapper(User,
users,
properties={
'addresses': relation(Address,
passive_updates=passive_updates)
})
mapper(Address, addresses)
sess = create_session()
u1 = User(username='******', fullname='jack')
u1.addresses.append(Address(email='jack1'))
u1.addresses.append(Address(email='jack2'))
sess.add(u1)
sess.flush()
a1 = u1.addresses[0]
eq_(
sa.select([addresses.c.username]).execute().fetchall(),
[('jack', ), ('jack', )])
assert sess.query(Address).get(a1.id) is u1.addresses[0]
u1.username = '******'
sess.flush()
assert u1.addresses[0].username == 'ed'
eq_(
sa.select([addresses.c.username]).execute().fetchall(), [('ed', ),
('ed', )])
sess.expunge_all()
eq_([Address(username='******'),
Address(username='******')],
sess.query(Address).all())
u1 = sess.query(User).get(u1.id)
u1.username = '******'
def go():
sess.flush()
if not passive_updates:
self.assert_sql_count(
testing.db, go, 4
) # test passive_updates=False; load addresses, update user, update 2 addresses
else:
self.assert_sql_count(testing.db, go,
1) # test passive_updates=True; update user
sess.expunge_all()
assert User(username='******',
addresses=[
Address(username='******'),
Address(username='******')
]) == sess.query(User).get(u1.id)
sess.expunge_all()
u1 = sess.query(User).get(u1.id)
u1.addresses = []
u1.username = '******'
sess.flush()
sess.expunge_all()
a1 = sess.query(Address).get(a1.id)
eq_(a1.username, None)
eq_(
sa.select([addresses.c.username]).execute().fetchall(), [(None, ),
(None, )])
u1 = sess.query(User).get(u1.id)
eq_(User(username='******', fullname='jack'), u1)
def define_harvester_tables():
global harvest_source_table
global harvest_job_table
global harvest_object_table
global harvest_gather_error_table
global harvest_object_error_table
global harvest_coupled_resource_table
harvest_source_table = Table(
'harvest_source',
metadata,
Column('id', types.UnicodeText, primary_key=True, default=make_uuid),
Column('url', types.UnicodeText, nullable=False),
Column('title', types.UnicodeText, default=u''),
Column('description', types.UnicodeText, default=u''),
Column('config', types.UnicodeText, default=u''),
Column('created', types.DateTime, default=datetime.datetime.utcnow),
Column('type', types.UnicodeText, nullable=False),
Column('active', types.Boolean, default=True),
Column('user_id', types.UnicodeText, default=u''),
Column('publisher_id', types.UnicodeText, default=u''),
)
# Was harvesting_job
harvest_job_table = Table(
'harvest_job',
metadata,
Column('id', types.UnicodeText, primary_key=True, default=make_uuid),
Column('created', types.DateTime, default=datetime.datetime.utcnow),
Column('gather_started', types.DateTime),
Column('gather_finished', types.DateTime),
Column('source_id', types.UnicodeText,
ForeignKey('harvest_source.id')),
Column('status', types.UnicodeText, default=u'New', nullable=False),
)
# Was harvested_document
harvest_object_table = Table(
'harvest_object',
metadata,
Column('id', types.UnicodeText, primary_key=True, default=make_uuid),
Column('guid', types.UnicodeText, default=u''),
Column('current', types.Boolean, default=False),
Column('gathered', types.DateTime, default=datetime.datetime.utcnow),
Column('fetch_started', types.DateTime),
Column('content', types.UnicodeText, nullable=True),
Column('fetch_finished', types.DateTime),
Column('metadata_modified_date', types.DateTime),
Column('retry_times', types.Integer),
Column('harvest_job_id', types.UnicodeText,
ForeignKey('harvest_job.id')),
Column('harvest_source_id', types.UnicodeText,
ForeignKey('harvest_source.id')),
Column(
'harvest_source_reference', types.UnicodeText
), # id according to the Harvest Source, for Gemini Coupled Resources
Column('package_id',
types.UnicodeText,
ForeignKey('package.id'),
nullable=True),
)
# New table
harvest_gather_error_table = Table(
'harvest_gather_error',
metadata,
Column('id', types.UnicodeText, primary_key=True, default=make_uuid),
Column('harvest_job_id', types.UnicodeText,
ForeignKey('harvest_job.id')),
Column('message', types.UnicodeText),
Column('created', types.DateTime, default=datetime.datetime.utcnow),
)
# New table
harvest_object_error_table = Table(
'harvest_object_error',
metadata,
Column('id', types.UnicodeText, primary_key=True, default=make_uuid),
Column('harvest_object_id', types.UnicodeText,
ForeignKey('harvest_object.id')),
Column('message', types.UnicodeText),
Column('stage', types.UnicodeText),
Column('created', types.DateTime, default=datetime.datetime.utcnow),
)
harvest_coupled_resource_table = Table(
'harvest_coupled_resource',
metadata,
Column('id', types.UnicodeText, primary_key=True, default=make_uuid),
Column('service_record_package_id',
types.UnicodeText,
ForeignKey('package.id'),
nullable=True),
Column('harvest_source_reference', types.UnicodeText, nullable=False),
Column('dataset_record_package_id',
types.UnicodeText,
ForeignKey('package.id'),
nullable=True),
)
mapper(
HarvestSource,
harvest_source_table,
properties={
'jobs':
relation(
HarvestJob,
lazy=True,
backref=u'source',
order_by=harvest_job_table.c.created,
),
},
)
mapper(
HarvestJob,
harvest_job_table,
)
mapper(
HarvestObject,
harvest_object_table,
properties={
'package': relation(
Package,
lazy=True,
backref='harvest_objects',
),
'job': relation(
HarvestJob,
lazy=True,
backref=u'objects',
),
'source': relation(
HarvestSource,
lazy=True,
backref=u'objects',
),
},
)
mapper(
HarvestGatherError,
harvest_gather_error_table,
properties={
'job': relation(HarvestJob, backref='gather_errors'),
},
)
mapper(
HarvestObjectError,
harvest_object_error_table,
properties={
'object': relation(HarvestObject, backref='errors'),
},
)
mapper(
HarvestCoupledResource,
harvest_coupled_resource_table,
properties={
'service_record':
relation(
Package,
primaryjoin=harvest_coupled_resource_table.c.
service_record_package_id == Package.id,
lazy=True,
backref='coupled_dataset',
),
'dataset_record':
relation(
Package,
primaryjoin=harvest_coupled_resource_table.c.
dataset_record_package_id == Package.id,
lazy=True,
backref='coupled_service',
),
},
)
event.listen(HarvestObject, 'before_insert',
harvest_object_before_insert_listener)
self.data = {}
else:
self.data = data
@classmethod
def by_activity_id(cls: Type[TActivityDetail],
activity_id: str) -> list["TActivityDetail"]:
return ckan.model.Session.query(cls) \
.filter_by(activity_id=activity_id).all()
meta.mapper(ActivityDetail,
activity_detail_table,
properties={
'activity':
orm.relation(Activity, backref=orm.backref('activity_detail'))
})
def _activities_limit(q: QActivity,
limit: int,
offset: Optional[int] = None) -> QActivity:
'''
Return an SQLAlchemy query for all activities at an offset with a limit.
'''
import ckan.model as model
# type_ignore_reason: incomplete SQLAlchemy types
q = q.order_by(desc(model.Activity.timestamp)) # type: ignore
if offset:
q = q.offset(offset)
if limit:
class TVDBSeries(Base):
__tablename__ = "tvdb_series"
id = Column(Integer, primary_key=True, autoincrement=False)
last_updated = Column(Integer)
expired = Column(Boolean)
name = Column(Unicode)
language = Column(Unicode)
rating = Column(Float)
status = Column(Unicode)
runtime = Column(Integer)
airs_time = Column(Unicode)
airs_dayofweek = Column(Unicode)
content_rating = Column(Unicode)
network = Column(Unicode)
overview = Column(Unicode)
imdb_id = Column(Unicode)
zap2it_id = Column(Unicode)
_banner = Column('banner', Unicode)
_first_aired = Column('first_aired', DateTime)
first_aired = text_date_synonym('_first_aired')
_aliases = Column('aliases', Unicode)
aliases = json_synonym('_aliases')
_actors = Column('actors', Unicode)
actors_list = json_synonym('_actors')
_posters = Column('posters', Unicode)
posters_list = json_synonym('_posters')
_genres = relation('TVDBGenre', secondary=genres_table)
genres = association_proxy('_genres', 'name')
episodes = relation('TVDBEpisode',
backref='series',
cascade='all, delete, delete-orphan')
def __init__(self, tvdb_id):
"""
Looks up movie on tvdb and creates a new database model for it.
These instances should only be added to a session via `session.merge`.
"""
self.id = tvdb_id
try:
series = TVDBRequest().get('series/%s' % self.id)
except requests.RequestException as e:
raise LookupError('Error updating data from tvdb: %s' % e)
self.language = 'en'
self.last_updated = series['lastUpdated']
self.name = series['seriesName']
self.rating = float(
series['siteRating']) if series['siteRating'] else 0.0
self.status = series['status']
self.runtime = int(series['runtime']) if series['runtime'] else 0
self.airs_time = series['airsTime']
self.airs_dayofweek = series['airsDayOfWeek']
self.content_rating = series['rating']
self.network = series['network']
self.overview = series['overview']
self.imdb_id = series['imdbId']
self.zap2it_id = series['zap2itId']
self.first_aired = series['firstAired']
self.expired = False
self.aliases = series['aliases']
self._banner = series['banner']
self._genres = [TVDBGenre(
id=name) for name in series['genre']] if series['genre'] else []
# Actors and Posters are lazy populated
self._actors = None
self._posters = None
def __repr__(self):
return '<TVDBSeries name=%s,tvdb_id=%s>' % (self.name, self.id)
@property
def banner(self):
if self._banner:
return TVDBRequest.BANNER_URL + self._banner
@property
def actors(self):
return self.get_actors()
@property
def posters(self):
return self.get_posters()
def get_actors(self):
if not self._actors:
log.debug('Looking up actors for series %s' % self.name)
try:
actors_query = TVDBRequest().get('series/%s/actors' % self.id)
self.actors_list = [a['name'] for a in actors_query
] if actors_query else []
except requests.RequestException as e:
if None is not e.response and e.response.status_code == 404:
self.actors_list = []
else:
raise LookupError('Error updating actors from tvdb: %s' %
e)
return self.actors_list
def get_posters(self):
if not self._posters:
log.debug('Getting top 5 posters for series %s' % self.name)
try:
poster_query = TVDBRequest().get('series/%s/images/query' %
self.id,
keyType='poster')
self.posters_list = [p['fileName'] for p in poster_query[:5]
] if poster_query else []
except requests.RequestException as e:
if None is not e.response and e.response.status_code == 404:
self.posters_list = []
else:
raise LookupError('Error updating posters from tvdb: %s' %
e)
return [TVDBRequest.BANNER_URL + p for p in self.posters_list]
def to_dict(self):
return {
'tvdb_id':
self.id,
'last_updated':
datetime.fromtimestamp(
self.last_updated).strftime('%Y-%m-%d %H:%M:%S'),
'expired':
self.expired,
'series_name':
self.name,
'language':
self.language,
'rating':
self.rating,
'status':
self.status,
'runtime':
self.runtime,
'airs_time':
self.airs_time,
'airs_dayofweek':
self.airs_dayofweek,
'content_rating':
self.content_rating,
'network':
self.network,
'overview':
self.overview,
'imdb_id':
self.imdb_id,
'zap2it_id':
self.zap2it_id,
'banner':
self.banner,
'posters':
self.posters,
'genres': [g for g in self.genres],
'actors':
self.actors,
'first_aired':
self.first_aired,
}
class BlurayMovie(Base):
__tablename__ = 'bluray_movies'
id = Column(Integer, primary_key=True, autoincrement=False, nullable=False)
name = Column(Unicode)
url = Column(Unicode)
release_date = Column(Date)
year = year_property('release_date')
runtime = Column(Integer)
overview = Column(Unicode)
country = Column(Unicode)
studio = Column(Unicode)
rating = Column(Float)
bluray_rating = Column(Integer)
certification = Column(Unicode)
_genres = relation('BlurayGenre', secondary=genres_table, backref='movies')
genres = association_proxy('_genres', 'name')
updated = Column(DateTime, default=datetime.now, nullable=False)
def __init__(self, title, year):
if year:
title_year = '{} ({})'.format(title, year)
else:
title_year = title
params = {
'section': 'bluraymovies',
'country': 'ALL',
'keyword': title,
'_': str(int(time.time() * 1000)),
}
country_params = {'_': params['_']}
try:
response = bluray_request('quicksearch/search.php', **params)
if not response or 'items' not in response:
raise LookupError(
'No search results found for {} on blu-ray.com'.format(title_year)
)
search_results = response['items']
countries = bluray_request('countries.json.php', **country_params) or {}
search_results = sorted(
search_results, key=lambda k: extract_release_date(k)
)
except requests.RequestException as e:
raise LookupError('Error searching for {} on blu-ray.com: {}'.format(title_year, e))
# Simply take the first result unless year does not match
for result in search_results:
if year and str(year) != result['year']:
continue
self.id = int(result['url'].split('/')[-2])
self.name = result['title']
flag = result['flag']
country_code = (
flag.split('/')[-1].split('.')[0].lower()
) # eg. http://some/url/UK.png -> uk
# find country based on flag url, default United States
country = 'United States'
for c in countries['countries']:
if c['c'].lower() == country_code:
country = c['n']
self.country = country
self.release_date = extract_release_date(result)
self.bluray_rating = int(result['rating']) if result['rating'] else None
# Used for parsing some more data, sadly with soup
self.url = result['url']
movie_info_response = requests.get(self.url).content
movie_info = get_soup(movie_info_response)
# runtime and rating, should be the last span tag with class subheading
bluray_info = movie_info.find('div', attrs={'class': 'bluray'})
bluray_info = bluray_info.find_all('span', attrs={'class': 'subheading'})[
-1
].text.split('|')
self.studio = bluray_info[0].strip()
for info in bluray_info[1:]:
if 'min' in info:
self.runtime = int(info.replace('min', '').strip())
elif 'Rated' in info:
self.certification = info.replace('Rated', '').strip()
# rating
rating_tag = movie_info.find('div', id='ratingscore')
self.rating = float(rating_tag.text.strip()) if rating_tag else None
# Third onecol_content contains some information we want
onecol_content = movie_info.find_all('div', attrs={'class': 'onecol_content'})[2]
# overview, genres etc
contents = onecol_content.find('div').find('div')
overview_tag = contents.find('p')
self.overview = overview_tag.text.strip() if overview_tag else None
# genres
genres_table = contents.find('table')
if not genres_table:
break
genres_content = genres_table.find_all('tr')
if not genres_content:
break
genres = set()
for genre in genres_content:
genres.add(genre.find('td').text.strip())
self._genres = [BlurayGenre(name=genre) for genre in genres]
break
else:
raise LookupError('No search results found for {} on blu-ray.com'.format(title_year))
class GentooInstalledPackagePropertiesRel(object):
def __init__(self, installed_package_id, version_id, keyword_status,
masked, unmasked, world, repo_id):
self.installed_package_id = installed_package_id
self.version_id = version_id
self.keyword_status = keyword_status
self.masked = masked
self.unmasked = unmasked
self.world = world
self.repo_id = repo_id
mapper(GentooInstalledPackagePropertiesRel,
_gentoo_installed_package_props_table,
properties={
'install': relation(GentooInstalledPackagesRel),
})
_gentoo_installed_package_use_flags_table = Table(
'gentoo_installed_package_use_flags',
metadata,
Column('id', Integer, primary_key=True, autoincrement=True),
Column('installed_package_id',
Integer,
ForeignKey('%s.id' % 'gentoo_installed_packages'),
nullable=False),
Column('use_flag_id',
Integer,
ForeignKey('%s.id' % 'gentoo_use_flag_pool'),
nullable=False),
Column('enabled', SmallInteger,
class Answer(db.Model, SerializerMixin):
__tablename__ = 'answers'
id = Column(Integer, primary_key=True, autoincrement=True) # id
text = Column(String)
qid = Column(Integer, ForeignKey("questions.id"))
question = orm.relation("Question") # связь с таблицой questions
log = getLogger(__name__)
doi_table = Table(
u'doi',
meta.metadata,
Column(u'identifier', types.UnicodeText, primary_key=True),
Column(u'package_id',
types.UnicodeText,
ForeignKey(u'package.id', onupdate=u'CASCADE', ondelete=u'CASCADE'),
nullable=False,
unique=True),
Column(u'published', types.DateTime, nullable=True),
# Date DOI was published to DataCite
)
class DOI(DomainObject):
'''DOI Object'''
pass
meta.mapper(DOI,
doi_table,
properties={
u'dataset':
relation(Package,
backref=backref(u'doi',
cascade=u'all, delete-orphan'),
primaryjoin=doi_table.c.package_id.__eq__(Package.id))
})
def __init__(self, username, password, database, label, hidden=False):
self.database = database
self.username = username
self.password = password
self.label = label
self.hidden = hidden
url = URL(drivername=config.DATABASE_DRIVER, username=username,
password=password, host=config.DATABASE_HOST,
port=config.DATABASE_PORT, database=database,
query={'charset': 'utf8', 'use_unicode': 0})
self.engine = create_engine(url, convert_unicode=True, pool_recycle=3600)
self.metadata = metadata = MetaData(bind=self.engine)
class Solver(object):
""" Maps the Solver table """
pass
class SolverConfiguration(object):
""" Solver configuration mapping the SolverConfig table.
A solver configuration consists of a solver and a set of
parameters and their values.
"""
def get_name(self):
""" Returns the name of the solver configuration. """
return self.name
def __str__(self):
return self.get_name()
class Parameter(object):
""" Maps the Parameters table. """
pass
class ParameterInstance(object):
""" Maps the n:m association table SolverConfig_has_Parameters,
which for a parameter specifies its value in the corresponding
solver configuration.
"""
pass
class Instance(object):
""" Maps the Instances table. """
def __str__(self):
return self.get_name()
def get_name(self):
if self.instance_classes[0] is None:
return self.name
pc = self.instance_classes[0]
parent_classes = [pc.name]
count = 1
while pc.parent_class:
pc = pc.parent_class
parent_classes.append(pc.name)
count += 1
if pc.parent_class:
return '/'.join(reversed(parent_classes)) + "/" + self.name
else:
return '/'.join(reversed(parent_classes)) + "/" + self.name
def get_class_hierarchy(self):
if self.instance_classes[0] is None:
return self.name
pc = self.instance_classes[0]
parent_classes = [pc.name]
while pc.parent_class:
pc = pc.parent_class
parent_classes.append(pc.name)
return reversed(parent_classes)
def get_property_value(self, property, db):
""" Returns the value of the property with the given name. """
try:
for p in self.properties:
if p.idProperty == int(property):
return p.get_value()
except:
return None
def get_instance(self, db):
"""
Decompresses the instance blob if necessary and returns it as string.
EDACC can store compressed and uncompressed instances. To distinguish
between them, we prepend the ASCII characters "LZMA" to a compressed instance.
"""
table = db.metadata.tables['Instances']
c_instance = table.c['instance']
c_id = table.c['idInstance']
# get prefix
instance_header = db.session.connection().execute(select([func.substring(c_instance, 1, 4)],
c_id == self.idInstance).select_from(
table)).first()[0]
data_length = db.session.connection().execute(select([func.length(c_instance)],
c_id == self.idInstance).select_from(
table)).first()[0]
if data_length > 32 * 1024 * 1024:
return "Instance too large for processing. Please use the EDACC GUI application."
if instance_header == 'LZMA': # compressed instance?
# get blob without LZMA prefix
instance_blob = db.session.connection().execute(select([func.substring(c_instance, 5)],
c_id == self.idInstance).select_from(
table)).first()[0]
return utils.lzma_decompress(instance_blob)
else:
return self.instance
def get_compressed_instance(self, db):
table = db.metadata.tables['Instances']
c_instance = table.c['instance']
c_id = table.c['idInstance']
# get prefix
instance_header = db.session.connection().execute(select([func.substring(c_instance, 1, 4)],
c_id == self.idInstance).select_from(
table)).first()[0]
data_length = db.session.connection().execute(select([func.length(c_instance)],
c_id == self.idInstance).select_from(
table)).first()[0]
if instance_header == 'LZMA': # compressed instance?
# get blob without LZMA prefix
instance_blob = db.session.connection().execute(select([func.substring(c_instance, 5)],
c_id == self.idInstance).select_from(
table)).first()[0]
return instance_blob, True
else:
return self.instance, False
def set_instance(self, uncompressed_instance):
""" Compresses the instance and sets the instance blob attribute """
self.instance = "LZMA" + utils.lzma_compress(uncompressed_instance)
class Experiment(object):
""" Maps the Experiment table. """
def get_num_jobs(self, db):
return db.session.query(db.ExperimentResult).filter_by(experiment=self).count()
#def get_num_runs(self, db):
# """ Returns the number of runs of the experiment """
# num_results = db.session.query(db.ExperimentResult) \
# .filter_by(experiment=self).count()
# num_solver_configs = db.session.query(db.SolverConfiguration) \
# .filter_by(experiment=self).count()
# num_instances = db.session.query(db.Instance) \
# .filter(db.Instance.experiments \
# .contains(self)).distinct().count()
# if num_solver_configs == 0 or num_instances == 0:
# return 0
# return num_results / num_solver_configs / num_instances
def get_solved_instance_ids_by_solver_id(self, db, instances, solver_configs):
if not solver_configs or not instances: return []
solver_config_ids = [sc.idSolverConfig for sc in solver_configs]
instance_ids = [i.idInstance for i in instances]
successful_runs = db.session.query(db.ExperimentResult.SolverConfig_idSolverConfig,
db.ExperimentResult.Instances_idInstance) \
.filter_by(experiment=self).filter(db.ExperimentResult.resultCode.like("1%")) \
.filter(db.ExperimentResult.Instances_idInstance.in_(instance_ids)) \
.filter(db.ExperimentResult.SolverConfig_idSolverConfig.in_(solver_config_ids)) \
.filter_by(status=1).all()
solved_instances = dict((sc.idSolverConfig, set()) for sc in solver_configs)
for run in successful_runs:
solved_instances[run.SolverConfig_idSolverConfig].add(run.Instances_idInstance)
return solved_instances
def get_sota_solvers(self, db, instances, solver_configs):
"""
Returns the set of state-of-the-art solvers of the experiment.
A solver is considered SOTA if no other solver solves a strict
superset of its solved instances.
"""
if not solver_configs or not instances: return []
solver_config_ids = [sc.idSolverConfig for sc in solver_configs]
instance_ids = [i.idInstance for i in instances]
successful_runs = db.session.query(db.ExperimentResult.SolverConfig_idSolverConfig,
db.ExperimentResult.Instances_idInstance) \
.filter_by(experiment=self).filter(db.ExperimentResult.resultCode.like("1%")) \
.filter(db.ExperimentResult.Instances_idInstance.in_(instance_ids)) \
.filter(db.ExperimentResult.SolverConfig_idSolverConfig.in_(solver_config_ids)) \
.filter_by(status=1).all()
solved_instances = dict((sc.idSolverConfig, set()) for sc in solver_configs)
for run in successful_runs:
solved_instances[run.SolverConfig_idSolverConfig].add(run.Instances_idInstance)
sota_solvers = []
sota_solved = set()
for solver in solved_instances:
isSOTA = True
for othersolver in solved_instances.iterkeys():
if solver == othersolver: continue
if solved_instances[othersolver] > solved_instances[solver]:
isSOTA = False
break
if isSOTA: sota_solvers.append(solver)
return [sc for sc in solver_configs if sc.idSolverConfig in sota_solvers]
def unique_solver_contributions(self, db, instances, solver_configs):
"""
Returns a dictionary that for each solver configuration specifies the set of IDs
of the instances that only this solver config solved.
"""
if not solver_configs or not instances: return {}
solver_config_ids = [sc.idSolverConfig for sc in solver_configs]
instance_ids = [i.idInstance for i in instances]
successful_runs = db.session.query(db.ExperimentResult.SolverConfig_idSolverConfig,
db.ExperimentResult.Instances_idInstance) \
.filter_by(experiment=self).filter(db.ExperimentResult.resultCode.like("1%")) \
.filter(db.ExperimentResult.Instances_idInstance.in_(instance_ids)) \
.filter(db.ExperimentResult.SolverConfig_idSolverConfig.in_(solver_config_ids)) \
.filter_by(status=1).all()
solved_instances = dict((sc.idSolverConfig, set()) for sc in solver_configs)
for run in successful_runs:
solved_instances[run.SolverConfig_idSolverConfig].add(run.Instances_idInstance)
sc_by_id = dict((sc.idSolverConfig, sc) for sc in solver_configs)
unique_solver_contribs = dict()
for solver in solved_instances:
solved = set([i for i in solved_instances[solver]])
for othersolver in solved_instances:
if othersolver == solver: continue
solved = solved.difference(solved_instances[othersolver])
unique_solver_contribs[sc_by_id[solver]] = solved
return unique_solver_contribs
def get_max_num_runs(self, db):
""" Returns the number of runs of the experiment """
res = db.session.query(func.max(db.ExperimentResult.run)).filter_by(experiment=self).first()
if res is None or res[0] is None: return 0
return res[0] + 1
def get_solved_instances(self, db):
""" Returns the instances of the experiment that any solver
solved in any of its runs
"""
instance_ids = [i[0] for i in db.session.query(db.ExperimentResult.Instances_idInstance) \
.filter_by(experiment=self).filter(db.ExperimentResult.resultCode.like('1%')) \
.filter_by(status=1).distinct().all()]
return db.session.query(db.Instance).filter(db.Instance.idInstance.in_(instance_ids)).all()
def get_fully_solved_instances(self, db):
""" Returns the instances of the experiment that all solvers
solved in all of their runs
"""
numInstances = db.session.query(db.Instance).options(joinedload_all('properties')) \
.filter(db.Instance.experiments.contains(self)).distinct().count()
if numInstances == 0: return 0
num_jobs_per_instance = db.session.query(db.ExperimentResult) \
.filter_by(experiment=self).count() / numInstances
instances = []
for i in self.instances:
if db.session.query(db.ExperimentResult) \
.filter(db.ExperimentResult.resultCode.like('1%')) \
.filter_by(experiment=self, instance=i, status=1) \
.count() == num_jobs_per_instance:
instances.append(i)
return instances
def get_unsolved_instances(self, db):
t_results = db.metadata.tables['ExperimentResults']
s = select([t_results.c['Instances_idInstance']],
and_(t_results.c['Experiment_idExperiment'] == self.idExperiment,
t_results.c['resultCode'].like('1%'),
t_results.c['status'] == 1),
from_obj=t_results).distinct()
ids = db.session.connection().execute(s).fetchall()
return db.session.query(db.Instance).options(joinedload_all('properties')).filter(
db.Instance.experiments.contains(self)).filter(
not_(db.Instance.idInstance.in_(list(r[0] for r in ids)))).all()
def get_instances(self, db):
return db.session.query(db.Instance).options(joinedload_all('properties')) \
.filter(db.Instance.experiments.contains(self)).distinct().all()
def get_num_solver_configs(self, db):
return db.session.query(db.SolverConfiguration) \
.filter_by(experiment=self).distinct().count()
def get_num_instances(self, db):
return db.session.query(db.Instance) \
.filter(db.Instance.experiments.contains(self)).distinct().count()
def get_total_instance_blob_size(self, db):
table = db.metadata.tables['Instances']
c_instance = table.c['instance']
c_id = table.c['idInstance']
instance_ids = [i.idInstance for i in self.get_instances(db)]
instance_sizes = db.session.connection().execute(select([func.length(c_instance)],
c_id.in_(instance_ids)).select_from(
table)).fetchall()
total_size = sum(i[0] for i in instance_sizes or [(0,)])
return total_size
def get_results_by_instance(self, db, solver_configs, instance, penalize_incorrect, penalize_factor=1,
result_property='resultTime'):
results_by_instance = dict((sc.idSolverConfig, dict()) for sc in solver_configs)
if not solver_configs: return results_by_instance
solver_config_ids = [sc.idSolverConfig for sc in solver_configs]
table = db.metadata.tables['ExperimentResults']
table_result_codes = db.metadata.tables['ResultCodes']
table_status_codes = db.metadata.tables['StatusCodes']
c = table.c
c_rc = table_result_codes.c
c_sc = table_status_codes.c
if result_property == 'resultTime':
c_cost = c['resultTime']
c_limit = c['CPUTimeLimit']
pass
elif result_property == 'wallTime':
c_cost = c['wallTime']
c_limit = c['wallClockTimeLimit']
pass
elif result_property == 'cost':
c_cost = c['cost']
c_limit = -1
pass
else:
# result property table
c_cost = 0
c_limit = -1
pass
join_expression = table.join(table_result_codes).join(table_status_codes)
select_statement = select([
c['idJob'],
c['status'],
c['resultCode'],
expression.label('result_code_description', c_rc['description']),
expression.label('status_code_description', c_sc['description']),
c['Instances_idInstance'],
c['SolverConfig_idSolverConfig'],
c['run'],
expression.label('cost',
expression.case([(
c['status'] > 0,
# only consider cost of "finished" jobs
c_cost if not penalize_incorrect else \
expression.case(
[(
table.c['resultCode'].like(
'1%'), c_cost)],
else_=c_limit * penalize_factor
)
)],
else_=None)
),
expression.label('limit', c_limit),
],
and_(
c['Experiment_idExperiment'] == self.idExperiment,
c['Instances_idInstance'] == instance.idInstance,
c['SolverConfig_idSolverConfig'].in_(solver_config_ids),
),
from_obj=join_expression,
)
results = db.session.connection().execute(select_statement)
for row in results:
results_by_instance[row.SolverConfig_idSolverConfig][row.run] = row
return results_by_instance
def get_result_matrix(self, db, solver_configs, instances, cost='resultTime', fixed_limit=None):
""" Returns the results as matrix of lists of result tuples, i.e.
Dict<idInstance, Dict<idSolverConfig, List of runs>> """
num_successful = dict(
(i.idInstance, dict((sc.idSolverConfig, 0) for sc in solver_configs)) for i in instances)
num_completed = dict(
(i.idInstance, dict((sc.idSolverConfig, 0) for sc in solver_configs)) for i in instances)
M = dict((i.idInstance, dict((sc.idSolverConfig, list()) for sc in solver_configs)) for i in instances)
solver_config_ids = [sc.idSolverConfig for sc in solver_configs]
instance_ids = [i.idInstance for i in instances]
if not solver_config_ids or not instance_ids:
return M, 0, 0
table = db.metadata.tables['ExperimentResults']
table_result_codes = db.metadata.tables['ResultCodes']
from_table = table
table_has_prop = db.metadata.tables['ExperimentResult_has_Property']
table_has_prop_value = db.metadata.tables['ExperimentResult_has_PropertyValue']
status_column = table.c['status']
result_code_column = table.c['resultCode']
if cost == 'resultTime':
cost_column = table.c['resultTime']
cost_property = db.ExperimentResult.resultTime
cost_limit_column = table.c['CPUTimeLimit']
if fixed_limit:
cost_column = expression.case([(table.c['resultTime'] > fixed_limit, fixed_limit)],
else_=table.c['resultTime'])
cost_limit_column = literal(fixed_limit)
status_column = expression.case([(table.c['resultTime'] > fixed_limit, literal(21))],
else_=table.c['status'])
result_code_column = expression.case([(table.c['resultTime'] > fixed_limit, literal(-21))],
else_=table.c['resultCode'])
elif cost == 'wallTime':
cost_column = table.c['wallTime']
cost_property = db.ExperimentResult.wallTime
cost_limit_column = table.c['wallClockTimeLimit']
if fixed_limit:
cost_column = expression.case([(table.c['wallTime'] > fixed_limit, fixed_limit)],
else_=table.c['wallTime'])
cost_limit_column = literal(fixed_limit)
status_column = expression.case([(table.c['wallTime'] > fixed_limit, literal(22))],
else_=table.c['status'])
result_code_column = expression.case([(table.c['wallTime'] > fixed_limit, literal(-22))],
else_=table.c['resultCode'])
elif cost == 'cost':
cost_column = table.c['cost']
cost_property = db.ExperimentResult.cost
inf = float('inf')
cost_limit_column = table.c['CPUTimeLimit'] # doesnt matter
else:
cost_column = table_has_prop_value.c['value']
cost_property = db.ResultPropertyValue.value
inf = float('inf')
cost_limit_column = table.c['CPUTimeLimit']
from_table = table.join(table_has_prop, and_(table_has_prop.c['idProperty'] == int(cost),
table_has_prop.c['idExperimentResults'] == table.c[
'idJob'])).join(table_has_prop_value)
s = select([table.c['idJob'], expression.label('resultCode', result_code_column),
expression.label('cost', cost_column), expression.label('status', status_column),
table.c['SolverConfig_idSolverConfig'], table.c['Instances_idInstance'],
table_result_codes.c['description'], expression.label('limit', cost_limit_column)],
and_(table.c['Experiment_idExperiment'] == self.idExperiment,
table.c['SolverConfig_idSolverConfig'].in_(solver_config_ids),
table.c['Instances_idInstance'].in_(instance_ids)),
from_obj=from_table.join(table_result_codes))
Run = namedtuple('Run', ['idJob', 'status', 'result_code_description', 'resultCode', 'resultTime',
'successful', 'penalized_time10', 'idSolverConfig', 'idInstance',
'penalized_time1', 'censored'])
for r in db.session.connection().execute(s):
if r.Instances_idInstance not in M: continue
if r.SolverConfig_idSolverConfig not in M[r.Instances_idInstance]: continue
if str(r.resultCode).startswith('1'): num_successful[r.Instances_idInstance][
r.SolverConfig_idSolverConfig] += 1
if r.status not in STATUS_PROCESSING: num_completed[r.Instances_idInstance][
r.SolverConfig_idSolverConfig] += 1
M[r.Instances_idInstance][r.SolverConfig_idSolverConfig].append(
Run(r.idJob, int(r.status), r[6], int(r.resultCode),
None if int(r.status) <= 0 else float(r.cost), str(r.resultCode).startswith('1'),
float(r.cost) if str(r.resultCode).startswith('1') else (inf if cost not in (
'resultTime', 'wallTime') else float(r.limit)) * 10,
r.SolverConfig_idSolverConfig, r.Instances_idInstance,
float(r.cost) if str(r.resultCode).startswith('1') else (
inf if cost not in ('resultTime', 'wallTime') else float(r.limit)),
not str(r.resultCode).startswith('1')))
return M, num_successful, num_completed
class ExperimentResult(object):
""" Maps the ExperimentResult table. Provides a function
to obtain a result property of a job.
"""
def get_time(self):
""" Returns the CPU time needed for this result or the
experiment's timeOut value if the status is
not correct (certified SAT/UNSAT answer).
"""
# if the job is being processed or the CC had a crash return None
if self.status <= 0:
return None
if self.status in (STATUS_FINISHED, 21):
return self.resultTime
return None
def get_penalized_time(self, p_factor=10):
if self.CPUTimeLimit == -1:
return float('inf')
else:
return self.CPUTimeLimit * p_factor
def get_property_value(self, property, db):
""" Returns the value of the property with the given name.
If the property is 'cputime' it returns the time.
If the property is an integer, it returns the value of the
associated Property with this id.
"""
if property == 'resultTime':
return self.get_time()
elif property == 'wallTime':
return self.wallTime
elif property == 'cost':
return self.cost
else:
try:
for pv in self.properties:
if pv.idProperty == int(property):
return pv.get_value()
except:
return None
def to_json(self):
return {
'idJob': self.idJob,
'Experiment_idExperiment': self.Experiment_idExperiment,
'Instances_idInstance': self.Instances_idInstance,
'run': self.run,
'resultCode': self.resultCode,
'resultTime': self.resultTime,
'status': self.status,
'seed': self.seed,
'startTime': str(self.startTime),
'computeQueue': self.computeQueue,
'priority': self.priority,
}
class ExperimentResultOutput(object):
pass
class InstanceClass(object):
def __str__(self):
return self.name
class ResultCodes(object):
def to_json(self):
return {
'code': self.resultCode,
'description': self.description,
}
class StatusCodes(object):
def to_json(self):
return {
'code': self.statusCode,
'description': self.description,
}
class SolverBinary(object):
pass
class Client(object):
pass
class Experiment_has_Client(object):
pass
class GridQueue(object):
pass
class Course(object):
pass
class ConfigurationScenario(object):
def get_parameter_domain(self, parameter_name):
""" Returns the domain name of a parameter. This can
be one of the following:
realDomain, flagDomain, categoricalDomain, ordinalDomain,
integerDomain, mixedDomain, optionalDomain.
"""
pgraph = self.solver_binary.solver.parameter_graph[0].serializedGraph
if pgraph is None: return None
tree = etree.parse(StringIO(pgraph))
if tree is None: return None
root = tree.getroot()
for node in root:
if node.tag == "parameters" and node[1].text == parameter_name:
return node[0].attrib.values()[0]
class ConfigurationScenarioParameter(object):
pass
class ParameterGraph(object):
pass
# competition tables
class User(object):
pass
class DBConfiguration(object):
pass
class CompetitionCategory(object):
def __str__(self):
return self.name
class BenchmarkType(object):
def __str__(self):
return self.name
# result and instance properties
class Property(object):
def is_result_property(self):
return self.propertyType == RESULT_PROPERTY_TYPE
def is_instance_property(self):
return self.propertyType == INSTANCE_PROPERTY_TYPE
def is_simple(self):
""" Returns whether the property is a simple property which is
stored in a way that's directly castable to a Python object
"""
return self.propertyValueType.lower() in ('float', 'double',
'int', 'integer',
'string')
def is_plotable(self):
""" Returns whether the property is a simple property which is
stored in a way that's directly castable to a Python object
and is numeric.
"""
return self.propertyValueType.lower() in ('float', 'double',
'int', 'integer')
class PropertyValueType(object):
pass
class ExperimentResultProperty(object):
def get_value(self):
valueType = self.property.propertyValueType.lower()
try:
if valueType in ('float', 'double'):
return float(self.values[0].value)
elif valueType in ('int', 'integer'):
return int(self.values[0].value)
else:
return None
except Exception:
return None
class ResultPropertyValue(object):
pass
class InstanceProperties(object):
def get_value(self):
valueType = self.property.propertyValueType.lower()
try:
if valueType in ('float', 'double',):
return float(self.value)
elif valueType in ('int', 'integer'):
return int(self.value)
elif valueType in ('string', ):
return str(self.value)
else:
return None
except ValueError:
return None
class VerifierConfig(object):
pass
class VerifierConfigParameter(object):
pass
self.Solver = Solver
self.SolverConfiguration = SolverConfiguration
self.Parameter = Parameter
self.ParameterInstance = ParameterInstance
self.Instance = Instance
self.Experiment = Experiment
self.ExperimentResult = ExperimentResult
self.ExperimentResultOutput = ExperimentResultOutput
self.InstanceClass = InstanceClass
self.GridQueue = GridQueue
self.ResultCodes = ResultCodes
self.StatusCodes = StatusCodes
self.SolverBinary = SolverBinary
self.Client = Client
self.Experiment_has_Client = Experiment_has_Client
self.ConfigurationScenario = ConfigurationScenario
self.ConfigurationScenarioParameter = ConfigurationScenarioParameter
self.Course = Course
self.VerifierConfig = VerifierConfig
self.VerifierConfigParameter = VerifierConfigParameter
self.User = User
self.DBConfiguration = DBConfiguration
self.CompetitionCategory = CompetitionCategory
self.BenchmarkType = BenchmarkType
self.Property = Property
self.PropertyValueType = PropertyValueType
self.ExperimentResultProperty = ExperimentResultProperty
self.ResultPropertyValue = ResultPropertyValue
self.InstanceProperties = InstanceProperties
self.ParameterGraph = ParameterGraph
metadata.reflect()
schema.Table("instanceClass", metadata,
schema.Column('parent', sqlalchemy.Integer, schema.ForeignKey("instanceClass.idinstanceClass")),
useexisting=True, autoload=True
)
schema.Table("ExperimentResults", metadata,
schema.Column('cost', sqlalchemy.Float),
useexisting=True, autoload=True
)
schema.Table("Experiment", metadata,
schema.Column('costPenalty', sqlalchemy.Float),
useexisting=True, autoload=True
)
schema.Table("SolverConfig", metadata,
schema.Column('cost', sqlalchemy.Float),
useexisting=True, autoload=True
)
# Table-Class mapping
mapper(VerifierConfig, metadata.tables['VerifierConfig'],
properties={
'parameters': relation(VerifierConfigParameter, backref='verifier_config'),
}
)
mapper(VerifierConfigParameter, metadata.tables['VerifierConfig_has_VerifierParameter'])
mapper(Course, metadata.tables['Course'])
mapper(GridQueue, metadata.tables['gridQueue'])
mapper(Client, metadata.tables['Client'],
properties={
'grid_queue': relationship(GridQueue, backref='clients'),
'experiments': relationship(Experiment,
secondary=metadata.tables['Experiment_has_Client'], backref='clients'),
}
)
mapper(Experiment_has_Client, metadata.tables['Experiment_has_Client'])
mapper(Parameter, metadata.tables['Parameters'])
mapper(InstanceClass, metadata.tables['instanceClass'],
properties={
'parent_class': relationship(InstanceClass,
remote_side=metadata.tables['instanceClass'].c['idinstanceClass'],
lazy="joined", join_depth=10, backref='subclasses')
}
)
mapper(Instance, metadata.tables['Instances'],
properties={
'instance': deferred(metadata.tables['Instances'].c.instance),
'instance_classes': relationship(InstanceClass,
secondary=metadata.tables['Instances_has_instanceClass'],
backref='instances',
lazy="joined"),
'properties': relation(InstanceProperties, backref='instance'),
}
)
mapper(Solver, metadata.tables['Solver'],
properties={
'code': deferred(metadata.tables['Solver'].c.code),
'binaries': relation(SolverBinary, backref='solver'),
'parameters': relation(Parameter, backref='solver'),
'competition_categories': relationship(
CompetitionCategory,
backref='solvers',
secondary=metadata.tables['Solver_has_CompetitionCategory']),
'parameter_graph': relation(ParameterGraph),
'description_pdf': deferred(metadata.tables['Solver'].c.description_pdf),
}
)
mapper(SolverBinary, metadata.tables['SolverBinaries'],
properties={
'binaryArchive': deferred(metadata.tables['SolverBinaries'].c.binaryArchive),
}
)
mapper(ParameterInstance, metadata.tables['SolverConfig_has_Parameters'],
properties={
'parameter': relation(Parameter)
}
)
mapper(SolverConfiguration, metadata.tables['SolverConfig'],
properties={
'parameter_instances': relation(ParameterInstance, backref="solver_configuration"),
'solver_binary': relation(SolverBinary, backref="solver_configurations"),
'experiment': relation(Experiment),
}
)
mapper(ParameterGraph, metadata.tables['ParameterGraph'])
mapper(ConfigurationScenarioParameter, metadata.tables['ConfigurationScenario_has_Parameters'],
properties={
'parameter': relation(Parameter)
}
)
mapper(ConfigurationScenario, metadata.tables['ConfigurationScenario'],
properties={
'parameters': relation(ConfigurationScenarioParameter),
'solver_binary': relation(SolverBinary),
'course': relation(Course, backref='configuration_scenario'),
}
)
mapper(Experiment, metadata.tables['Experiment'],
properties={
'instances': relationship(Instance,
secondary=metadata.tables['Experiment_has_Instances'],
backref='experiments'),
'solver_configurations': relation(SolverConfiguration),
'grid_queue': relationship(GridQueue,
secondary=metadata.tables['Experiment_has_gridQueue']),
'results': relation(ExperimentResult),
'configuration_scenario': relation(ConfigurationScenario, uselist=False),
'verifier_config': relation(VerifierConfig, backref='experiment', uselist=False),
}
)
mapper(StatusCodes, metadata.tables['StatusCodes'])
mapper(ResultCodes, metadata.tables['ResultCodes'])
mapper(ExperimentResultOutput, metadata.tables['ExperimentResultsOutput'])
mapper(ExperimentResult, metadata.tables['ExperimentResults'],
properties={
'output': relation(ExperimentResultOutput, backref='result', uselist=False),
'solver_configuration': relation(SolverConfiguration, backref=backref('runs', passive_deletes=True)),
'properties': relationship(ExperimentResultProperty, backref='experiment_result'),
'experiment': relation(Experiment, backref='experiment_results'),
'instance': relation(Instance, backref='results'),
'status_code': relation(StatusCodes, uselist=False),
'result_code': relation(ResultCodes, uselist=False),
'computeNode': deferred(metadata.tables['ExperimentResults'].c.computeNode),
'computeNodeIP': deferred(metadata.tables['ExperimentResults'].c.computeNodeIP),
'client': relation(Client),
}
)
mapper(User, metadata.tables['User'],
properties={
'solvers': relation(Solver, backref='user'),
'source_classes': relation(InstanceClass, backref='user'),
'benchmark_types': relation(BenchmarkType, backref='user')
}
)
mapper(DBConfiguration, metadata.tables['DBConfiguration'])
mapper(CompetitionCategory, metadata.tables['CompetitionCategory'])
mapper(BenchmarkType, metadata.tables['BenchmarkType'],
properties={
'instances': relation(Instance, backref='benchmark_type')
}
)
mapper(Property, metadata.tables['Property'])
mapper(PropertyValueType, metadata.tables['PropertyValueType'])
mapper(ExperimentResultProperty, metadata.tables['ExperimentResult_has_Property'],
properties={
'property': relationship(Property, backref='experiment_results', lazy='joined'),
'values': relation(ResultPropertyValue, backref='experiment_result_property', lazy='joined')
}
)
mapper(ResultPropertyValue, metadata.tables['ExperimentResult_has_PropertyValue'])
mapper(InstanceProperties, metadata.tables['Instance_has_Property'],
properties={
'property': relationship(Property, backref='instances')
}
)
self.session = scoped_session(sessionmaker(bind=self.engine, autocommit=False,
autoflush=False))
# initialize DBConfiguration table if not already done
if self.session.query(DBConfiguration).get(0) is None:
dbConfig = DBConfiguration()
dbConfig.id = 0
dbConfig.competition = False
dbConfig.competitionPhase = None
self.session.add(dbConfig)
self.session.commit()
self.db_is_competition = self.session.query(self.DBConfiguration).get(0).competition
if not self.db_is_competition:
self.db_competition_phase = None
else:
self.db_competition_phase = self.session.query(self.DBConfiguration).get(0).competitionPhase
class PackageExtra(core.StatefulObjectMixin, domain_object.DomainObject):
def related_packages(self):
return [self.package]
meta.mapper(
PackageExtra,
package_extra_table,
properties={
'package':
orm.relation(
_package.Package,
backref=orm.backref(
'_extras',
collection_class=orm.collections.attribute_mapped_collection(
u'key'),
cascade='all, delete, delete-orphan',
),
),
},
order_by=[package_extra_table.c.package_id, package_extra_table.c.key],
extension=[extension.PluginMapperExtension()],
)
def _create_extra(key, value):
return PackageExtra(key=text_type(key), value=value)
_package.Package.extras = association_proxy('_extras',
class Corpus(Base):
__tablename__ = 'corpus'
def __repr__(self):
return "<Corpus (%s)>" % self.id
id = Column(Integer, Sequence('corpus_seq_id', optional=True), primary_key=True)
UUID = Column(Unicode(36))
name = Column(Unicode(255))
description = Column(UnicodeText)
content = Column(UnicodeText(length=2**31))
enterer_id = Column(Integer, ForeignKey('user.id', ondelete='SET NULL'))
enterer = relation('User', primaryjoin='Corpus.enterer_id==User.id')
modifier_id = Column(Integer, ForeignKey('user.id', ondelete='SET NULL'))
modifier = relation('User', primaryjoin='Corpus.modifier_id==User.id')
form_search_id = Column(Integer, ForeignKey('formsearch.id', ondelete='SET NULL'))
form_search = relation('FormSearch')
datetime_entered = Column(DateTime)
datetime_modified = Column(DateTime, default=now)
tags = relation('Tag', secondary=CorpusTag.__table__)
forms = relation('Form', secondary=CorpusForm.__table__, backref='corpora')
# ``files`` attribute holds references to ``CorpusFile`` models, not ``File``
# models. This is a one-to-many relation, like form.translations.
files = relation('CorpusFile', backref='corpus', cascade='all, delete, delete-orphan')
def get_dict(self):
"""Return a Python dictionary representation of the Corpus. This
facilitates JSON-stringification, cf. utils.JSONOLDEncoder. Relational
data are truncated, e.g., corpus_dict['elicitor'] is a dict with keys
for 'id', 'first_name' and 'last_name' (cf. get_mini_user_dict above) and
lacks keys for other attributes such as 'username',
'personal_page_content', etc.
"""
return {
'id': self.id,
'UUID': self.UUID,
'name': self.name,
'description': self.description,
'content': self.content,
'enterer': self.get_mini_user_dict(self.enterer),
'modifier': self.get_mini_user_dict(self.modifier),
'form_search': self.get_mini_form_search_dict(self.form_search),
'datetime_entered': self.datetime_entered,
'datetime_modified': self.datetime_modified,
'tags': self.get_tags_list(self.tags),
'files': self.get_corpus_files_list(self.files)
}
def get_full_dict(self):
result = self.get_dict()
result['forms'] = self.get_forms_list(self.forms)
return result
makefilter = Keeper
@classmethod
def get_int(cls, input_):
try:
return int(input_)
except Exception:
return None
@classmethod
def get_form_references(cls, content):
"""Similar to ``get_ids_of_forms_referenced`` except that references are
assumed to be comma-delimited strings of digits -- all other text is
filtered out.
"""
digits_comma_only = cls.makefilter('1234567890,')
return filter(None, map(cls.get_int, digits_comma_only(content).split(',')))
Column('pospoints', SmallInteger),
UniqueConstraint('eventid', 'carid', name='eridx_2'))
Index('eridx_1', t_eventresults.c.eventid)
class EventResult(object):
def __init__(self, **kwargs):
for k, v in kwargs.iteritems():
if hasattr(self, k):
setattr(self, k, v)
mapper(EventResult,
t_eventresults,
properties={
'car': relation(Car, backref='results'),
'class': relation(Class)
})
## Announcer information precalculated
t_announcer = Table(
'announcer',
metadata,
Column('id', Integer, primary_key=True),
Column('eventid', Integer, ForeignKey('events.id')),
Column('carid', Integer, ForeignKey('cars.id')),
Column('classcode', String(16), ForeignKey('classlist.code')),
Column('lastcourse', Integer),
Column('rawdiff', Float),
Column('netdiff', Float),
Column(
boostedOntoRel = relationship(
CommandFit,
primaryjoin=commandFits_table.c.boosterID == fits_table.c.ID,
backref='booster_fit',
collection_class=attribute_mapped_collection('boostedID'),
cascade='all, delete, delete-orphan')
mapper(
es_Fit,
fits_table,
properties={
"_Fit__modules":
relation(
Module,
collection_class=HandledModuleList,
primaryjoin=and_(modules_table.c.fitID == fits_table.c.ID,
modules_table.c.projected == False), # noqa
order_by=modules_table.c.position,
cascade='all, delete, delete-orphan'),
"_Fit__projectedModules":
relation(Module,
collection_class=HandledProjectedModList,
cascade='all, delete, delete-orphan',
single_parent=True,
primaryjoin=and_(modules_table.c.fitID == fits_table.c.ID,
modules_table.c.projected == True)), # noqa
"owner":
relation(User, backref="fits"),
"itemID":
fits_table.c.shipID,
"shipID":
def setup():
if model.user_table.exists() and not user_extra_table.exists():
user_extra_table.create()
log.debug('User extra table created')
def _create_extra(key, value):
return UserExtra(key=unicode(key), value=value)
meta.mapper(UserExtra,
user_extra_table,
properties={
'user':
orm.relation(
user.User,
backref=orm.backref('_extras',
collection_class=orm.collections.
attribute_mapped_collection(u'key'),
cascade='all, delete, delete-orphan'))
},
order_by=[user_extra_table.c.user_id, user_extra_table.c.key])
_extras_active = vdm.sqlalchemy.stateful.DeferredProperty(
'_extras', vdm.sqlalchemy.stateful.StatefulDict)
setattr(user.User, 'extras_active', _extras_active)
user.User.extras = vdm.sqlalchemy.stateful.OurAssociationProxy(
'extras_active', 'value', creator=_create_extra)
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with eos. If not, see <http://www.gnu.org/licenses/>.
# ===============================================================================
from sqlalchemy import Column, String, Integer, Boolean, ForeignKey, Table
from sqlalchemy.orm import relation, mapper, synonym, deferred
from eos.db import gamedata_meta
from eos.types import Group, Icon, Category
groups_table = Table(
"invgroups", gamedata_meta, Column("groupID", Integer, primary_key=True),
Column("groupName", String), Column("description", String),
Column("published", Boolean),
Column("categoryID", Integer, ForeignKey("invcategories.categoryID")),
Column("iconID", Integer, ForeignKey("icons.iconID")))
mapper(Group,
groups_table,
properties={
"category": relation(Category, backref="groups"),
"icon": relation(Icon),
"ID": synonym("groupID"),
"name": synonym("groupName"),
"description": deferred(groups_table.c.description)
})
class TVMazeSeries(Base):
__tablename__ = 'tvmaze_series'
tvmaze_id = Column(Integer, primary_key=True)
status = Column(Unicode)
rating = Column(Float)
genres = relation(TVMazeGenre, secondary=genres_table)
weight = Column(Integer)
updated = Column(DateTime) # last time show was updated at tvmaze
name = Column(Unicode)
language = Column(Unicode)
_schedule = Column('schedule', Unicode)
schedule = json_synonym('_schedule')
url = Column(String)
original_image = Column(String)
medium_image = Column(String)
tvdb_id = Column(Integer)
tvrage_id = Column(Integer)
premiered = Column(DateTime)
year = Column(Integer)
summary = Column(Unicode)
webchannel = Column(String)
runtime = Column(Integer)
show_type = Column(String)
network = Column(Unicode)
episodes = relation('TVMazeEpisodes',
order_by='TVMazeEpisodes.season_number',
cascade='all, delete, delete-orphan',
backref='series')
last_update = Column(DateTime) # last time we updated the db for the show
def __init__(self, series, session):
self.tvmaze_id = series['id']
self.update(series, session)
def to_dict(self):
return {
'tvmaze_id': self.tvmaze_id,
'status': self.status,
'rating': self.rating,
'genres': [genre.name for genre in self.genres],
'weight': self.weight,
'updated': self.updated,
'name': self.name,
'language': self.language,
'schedule': self.schedule,
'url': self.url,
'original_image': self.original_image,
'medium_image': self.medium_image,
'tvdb_id': self.tvdb_id,
'tvrage_id': self.tvrage_id,
'premiered': self.premiered,
'year': self.year,
'summary': self.summary,
'webchannel': self.webchannel,
'runtime': self.runtime,
'show_type': self.show_type,
'network': self.network,
'last_update': self.last_update
}
def update(self, series, session):
self.status = series['status']
self.rating = series['rating']['average']
self.weight = series['weight']
self.updated = datetime.fromtimestamp(series['updated'])
self.name = series['name']
self.language = series['language']
self.schedule = series['schedule']
self.url = series['url']
self.original_image = series.get('image').get(
'original') if series.get('image') else None
self.medium_image = series.get('image').get('medium') if series.get(
'image') else None
self.tvdb_id = series['externals'].get('thetvdb')
self.tvrage_id = series['externals'].get('tvrage')
self.premiered = parser.parse(
series.get('premiered'),
ignoretz=True) if series.get('premiered') else None
self.year = int(
series.get('premiered')[:4]) if series.get('premiered') else None
self.summary = series['summary']
self.webchannel = series.get('web_channel')['name'] if series.get(
'web_channel') else None
self.runtime = series['runtime']
self.show_type = series['type']
self.network = series.get('network')['name'] if series.get(
'network') else None
self.last_update = datetime.now()
self.genres[:] = get_db_genres(series['genres'], session)
def __repr__(self):
return '<TVMazeSeries(title=%s,id=%s,last_update=%s)>' % (
self.name, self.tvmaze_id, self.last_update)
def __str__(self):
return self.name
@property
def expired(self):
if not self.last_update:
log.debug('no last update attribute, series set for update')
return True
time_dif = datetime.now() - self.last_update
expiration = time_dif.days > UPDATE_INTERVAL
return expiration
import sqlalchemy as rdb
from sqlalchemy.orm import mapper, relation, column_property, backref
import schema
import domain
# Users
# general representation of a person
mapper(domain.User,
schema.users,
properties={"user_addresses": relation(domain.UserAddress)})
# Groups
mapper(
domain.Group,
schema.groups,
primary_key=[schema.groups.c.group_id],
properties={
"members":
relation(domain.GroupMembership),
"group_principal_id":
column_property(
#
# !+ ATTENTION: the following sqlalchemy str concat (on c.type)
# gives some VERY strange behaviour :
#
# print "group." + schema.groups.c.type + "."
# >>> :type_1 || groups.type || :param_1
#
# print group.groups.type.
extension=[
vdm.sqlalchemy.Revisioner(group_revision_table),
],
)
vdm.sqlalchemy.modify_base_object_mapper(Group, core.Revision, core.State)
GroupRevision = vdm.sqlalchemy.create_object_version(meta.mapper, Group,
group_revision_table)
meta.mapper(
Member,
member_table,
properties={
'group':
orm.relation(Group,
backref=orm.backref('member_all',
cascade='all, delete-orphan')),
},
extension=[
vdm.sqlalchemy.Revisioner(member_revision_table),
],
)
vdm.sqlalchemy.modify_base_object_mapper(Member, core.Revision, core.State)
MemberRevision = vdm.sqlalchemy.create_object_version(meta.mapper, Member,
member_revision_table)
#TODO
MemberRevision.related_packages = lambda self: [self.continuity.package]
HIERARCHY_CTE = """
res_dict = ckan.lib.dictization.table_dictize(self,
context={'model': model})
return activity.ActivityDetail(activity_id, self.id, u"Resource",
activity_type,
{'resource': res_dict})
## Mappers
meta.mapper(Resource, resource_table, properties={
'package': orm.relation(
Package,
# all resources including deleted
# formally package_resources_all
backref=orm.backref('resources_all',
collection_class=ordering_list('position'),
cascade='all, delete',
order_by=resource_table.c.position,
),
)
},
order_by=[resource_table.c.package_id],
extension=[vdm.sqlalchemy.Revisioner(resource_revision_table),
extension.PluginMapperExtension(),
],
)
## VDM
vdm.sqlalchemy.modify_base_object_mapper(Resource, core.Revision, core.State)
q = q.filter(AuthorizationGroup.users.contains(user))
return q.count() == 1
def add_user_to_authorization_group(user, authorization_group, role):
assert not user_in_authorization_group(user, authorization_group)
from authz import add_user_to_role
meta.Session.add(authorization_group)
authorization_group.users.append(user)
add_user_to_role(user, role, authorization_group)
def remove_user_from_authorization_group(user, authorization_group):
assert user_in_authorization_group(user, authorization_group)
from authz import remove_user_from_role, AuthorizationGroupRole
meta.Session.add(authorization_group)
authorization_group.users.remove(user)
q = meta.Session.query(AuthorizationGroupRole)
q = q.filter_by(authorization_group=authorization_group,
user=user)
for agr in q:
remove_user_from_role(user, agr.role, authorization_group)
meta.mapper(AuthorizationGroup, authorization_group_table, properties={
'users': orm.relation(user.User, lazy=True, secondary=authorization_group_user_table,
backref=orm.backref('authorization_groups', lazy=True))
},
order_by=authorization_group_table.c.name)
meta.mapper(AuthorizationGroupUser, authorization_group_user_table)
class Fqdn(Base):
__tablename__ = _TN
_instance_label = 'fqdn'
id = Column(Integer, Sequence('%s_id_seq' % _TN), primary_key=True)
name = Column(AqStr(63), nullable=False)
dns_domain_id = Column(Integer,
ForeignKey('dns_domain.id',
name='%s_dns_domain_fk' % _TN),
nullable=False)
dns_environment_id = Column(Integer,
ForeignKey('dns_environment.id',
name='%s_dns_env_fk' % _TN),
nullable=False)
creation_date = deferred(
Column(DateTime, default=datetime.now, nullable=False))
dns_domain = relation(DnsDomain, innerjoin=True)
dns_environment = relation(DnsEnvironment, innerjoin=True)
__table_args__ = (UniqueConstraint(dns_domain_id,
name,
dns_environment_id,
name='%s_domain_name_env_uk' % _TN),
Index('%s_dns_env_idx' % _TN, dns_environment_id))
@property
def fqdn(self):
return self.name + '.' + self.dns_domain.name
@classmethod
def get_unique(cls,
session,
fqdn=None,
dns_environment=None,
name=None,
dns_domain=None,
**kwargs):
if fqdn:
if name or dns_domain: # pragma: no cover
raise TypeError("fqdn and name/dns_domain should not be mixed")
(name, dns_domain) = parse_fqdn(session, fqdn)
if not isinstance(dns_environment, DnsEnvironment):
dns_environment = DnsEnvironment.get_unique_or_default(
session, dns_environment)
return super(Fqdn, cls).get_unique(session,
name=name,
dns_domain=dns_domain,
dns_environment=dns_environment,
**kwargs)
@classmethod
def get_or_create(cls,
session,
dns_environment=None,
preclude=False,
ignore_name_check=False,
query_options=None,
**kwargs):
fqdn = cls.get_unique(session,
dns_environment=dns_environment,
query_options=query_options,
**kwargs)
if fqdn:
if preclude:
_raise_custom(preclude, ArgumentError,
"{0} already exists.".format(fqdn))
return fqdn
if not isinstance(dns_environment, DnsEnvironment):
dns_environment = DnsEnvironment.get_unique_or_default(
session, dns_environment)
fqdn = cls(session=session,
dns_environment=dns_environment,
ignore_name_check=ignore_name_check,
**kwargs)
session.add(fqdn)
return fqdn
@classmethod
def check_name(cls, name, dns_domain, ignore_name_check=False):
""" Validate the name parameter """
if not isinstance(name, basestring): # pragma: no cover
raise TypeError("%s: name must be a string." % cls.name)
if not isinstance(dns_domain, DnsDomain): # pragma: no cover
raise TypeError("%s: dns_domain must be a DnsDomain." % cls.name)
# Allow SRV records to opt out from this test
if not ignore_name_check:
DnsDomain.check_label(name)
# The limit for DNS name length is 255, assuming wire format. This
# translates to 253 for simple ASCII text; see:
# http://www.ops.ietf.org/lists/namedroppers/namedroppers.2003/msg00964.html
if len(name) + 1 + len(dns_domain.name) > 253:
raise ArgumentError('The fully qualified domain name is too long.')
def _check_session(self, session):
if not session or not isinstance(session, Session): # pragma: no cover
raise InternalError("%s needs a session." %
self._get_class_label())
def __init__(self,
session=None,
name=None,
dns_domain=None,
fqdn=None,
dns_environment=None,
ignore_name_check=False,
**kwargs):
if fqdn:
if name or dns_domain: # pragma: no cover
raise TypeError("fqdn and name/dns_domain should not be mixed")
self._check_session(session)
(name, dns_domain) = parse_fqdn(session, fqdn)
self.check_name(name, dns_domain, ignore_name_check)
if not isinstance(dns_environment, DnsEnvironment):
self._check_session(session)
dns_environment = DnsEnvironment.get_unique_or_default(
session, dns_environment)
super(Fqdn, self).__init__(name=name,
dns_domain=dns_domain,
dns_environment=dns_environment,
**kwargs)
@classmethod
def name_exists(cls, name):
'''Returns true if there is a vocabulary with the same name (case insensitive)'''
query = meta.Session.query(cls)
return query.filter(func.lower(cls.name) == func.lower(name)).first() is not None
class VocabularyServiceTerm(DomainObject):
"""A VocabularyServiceTerm object represents a term from an external vocabulary
used for populating and controlling a metadata schema field"""
def __init__(self, vocabulary_service_id=None, label=None, uri=None):
self.vocabulary_service_id = vocabulary_service_id
self.label = label
self.uri = uri
@classmethod
def get(cls, reference):
'''Returns a VocabularyServiceTerm object referenced by its id.'''
query = meta.Session.query(cls).filter(cls.id == reference)
vocabulary_service_term = query.first()
return vocabulary_service_term
meta.mapper(VocabularyService, vocabulary_service_table, properties={
'terms': relation(lambda: VocabularyServiceTerm, order_by=lambda: VocabularyServiceTerm.label)
})
meta.mapper(VocabularyServiceTerm, vocabulary_service_term_table)
return cls.extra_columns
## Mappers
meta.mapper(
Resource,
resource_table,
properties={
'resource_group':
orm.relation(
ResourceGroup,
# all resources including deleted
# formally package_resources_all
backref=orm.backref(
'resources_all',
collection_class=ordering_list('position'),
cascade='all, delete',
order_by=resource_table.c.position,
),
)
},
order_by=[resource_table.c.resource_group_id],
extension=[
vdm.sqlalchemy.Revisioner(resource_revision_table),
extension.PluginMapperExtension(),
],
)
meta.mapper(
ResourceGroup,