class QCCrossMatch(Entity):
"""
2009-9-22
add unique constraint ('strainid', 'target_id', 'qc_method_id')
2008-08-26
"""
strain = ManyToOne("Strain",
colname='strainid',
ondelete='CASCADE',
onupdate='CASCADE')
target_id = Field(Integer)
qc_method = ManyToOne("%s.QCMethod" % __name__,
colname='qc_method_id',
ondelete='CASCADE',
onupdate='CASCADE')
mismatch_rate = Field(Float)
no_of_mismatches = Field(Integer)
no_of_non_NA_pairs = Field(Integer)
readme = ManyToOne("%s.README" % __name__,
colname='readme_id',
ondelete='CASCADE',
onupdate='CASCADE')
using_options(tablename='qc_cross_match')
using_table_options(mysql_engine='InnoDB')
using_table_options(
UniqueConstraint('strainid', 'target_id', 'qc_method_id'))
class DataVote(Entity):
using_options(tablename='vote')
user = ManyToOne('DataUser')
card = ManyToOne('DataCard')
@classmethod
def get_vote(cls, card, user):
'''Return Vote instance which match with user and card
In:
- ``card`` -- DataCard instance
- ``user`` -- DataUser instance
Return:
- DataVote instance
'''
return cls.get_by(user=user, card=card)
@classmethod
def has_voted(cls, card, user):
'''Return if a user has voted for a given card
In:
- ``card`` -- DataCard instance
- ``user`` -- DataUser instance
Return:
- True if a vote is found, False otherwise
'''
return cls.get_vote(card, user) is not None
@classmethod
def count_votes(cls, card):
q = cls.query
q = q.filter(cls.card == card)
return q.count()
class DataBoardManager(Entity):
using_options(tablename='user_managed_boards__board_managers')
board = ManyToOne('DataBoard', primary_key=True, ondelete='CASCADE')
member = ManyToOne('DataUser',
primary_key=True,
ondelete='CASCADE',
colname=['user_username', 'user_source'])
class HaploGroupPairwiseGeneticDist(Entity):
"""
2009-4-16
genetic distance between each haplogroup pair
"""
haplo_group1 = ManyToOne('HaploGroup',
colname='haplo_group_id1',
ondelete='CASCADE',
onupdate='CASCADE')
haplo_group2 = ManyToOne('HaploGroup',
colname='haplo_group_id2',
ondelete='CASCADE',
onupdate='CASCADE')
mismatch_rate = Field(Float)
no_of_mismatches = Field(Integer)
no_of_non_NA_pairs = Field(Integer)
created_by = Field(String(200))
updated_by = Field(String(200))
date_created = Field(DateTime, default=datetime.now)
date_updated = Field(DateTime)
using_options(tablename='haplo_group_pairwise_genetic_dist',
metadata=__metadata__,
session=__session__)
using_table_options(mysql_engine='InnoDB')
using_table_options(UniqueConstraint('haplo_group_id1', 'haplo_group_id2'))
class SNPsABAlleleMapping(Entity):
snp = ManyToOne('SNPs',
colname='snps_id',
ondelete='CASCADE',
onupdate='CASCADE')
allele_A_nt = Field(String(2))
allele_B_nt = Field(String(2))
tg_snps_name = Field(String(200))
NA_rate = Field(Float)
no_of_NAs = Field(Integer)
no_of_totals = Field(Integer)
relative_NA_rate = Field(Float)
relative_no_of_NAs = Field(Integer)
relative_no_of_totals = Field(Integer)
mismatch_rate = Field(Float)
no_of_mismatches = Field(Integer)
no_of_non_NA_pairs = Field(Integer)
readme = ManyToOne("README",
colname='readme_id',
ondelete='CASCADE',
onupdate='CASCADE')
created_by = Field(String(128))
updated_by = Field(String(128))
date_created = Field(DateTime, default=datetime.now)
date_updated = Field(DateTime)
using_options(tablename='snps_ab_allele_mapping',
metadata=__metadata__,
session=__session__)
using_table_options(mysql_engine='InnoDB')
class DataBoardMember(Entity):
using_options(tablename='user_boards__board_members')
board = ManyToOne('DataBoard', primary_key=True, ondelete='CASCADE')
member = ManyToOne('DataUser',
primary_key=True,
ondelete='CASCADE',
colname=['user_username', 'user_source'])
notify = Field(Integer, default=lambda: 1)
class DataComment(Entity):
"""Comment mapper
"""
using_options(tablename='comment')
comment = Field(UnicodeText, default=u'')
creation_date = Field(DateTime)
card = ManyToOne('DataCard')
author = ManyToOne('DataUser')
class DataAsset(Entity):
using_options(tablename='asset')
filename = Field(Unicode(255), primary_key=True)
creation_date = Field(DateTime)
author = ManyToOne('DataUser')
card = ManyToOne('DataCard')
cover = ManyToOne('DataCard')
@classmethod
def get_all(cls, card):
return cls.query.filter_by(card=card).all()
@classmethod
def add(cls, filename, card, author):
return cls(filename=filename,
card=card,
author=author,
creation_date=datetime.datetime.utcnow())
@classmethod
def remove(cls, card, filename):
file = cls.get_by_filename(filename)
file.delete()
@classmethod
def remove_all(cls, card):
q = cls.query
q = q.filter_by(card=card)
q.delete()
@classmethod
def has_cover(cls, card):
q = cls.query
q = q.filter_by(cover=card)
return q.count() == 1
@classmethod
def get_cover(cls, card):
q = cls.query
q = q.filter_by(cover=card)
return q.first()
@classmethod
def set_cover(cls, card, asset):
cls.remove_cover(card)
asset.cover = card
@classmethod
def remove_cover(cls, card):
asset = cls.get_cover(card)
if asset is not None:
asset.cover = None
@classmethod
def get_by_filename(cls, filename):
return cls.get(filename)
class DataChecklist(Entity):
using_options(tablename='checklists')
title = Field(Unicode(255))
items = OneToMany('DataChecklistItem', order_by='index', inverse='checklist',
collection_class=ordering_list('index'))
card = ManyToOne('DataCard')
author = ManyToOne('DataUser')
index = Field(Integer)
@classmethod
def get_by_card(cls, card):
q = cls.query
q = q.filter_by(card=card)
q = q.order_by(cls.index)
return q.all()
def update(self, other):
self.title = other.title
self.index = other.index
for item in other.items:
self.items.append(DataChecklistItem(title=item.title,
index=item.index,
done=False))
database.session.flush()
def __unicode__(self):
titles = [item.title for item in self.items if item.title]
if self.title:
titles.insert(0, self.title)
return u'\n'.join(titles)
def to_indexable(self):
return unicode(self)
def add_item_from_str(self, text):
item = DataChecklistItem.new_from_str(text)
return self.add_item(item)
def add_item(self, item):
self.items.append(item)
return item
def insert_item(self, index, item):
self.items.insert(index, item)
def remove_item(self, item):
self.items.remove(item)
def delete_item(self, item):
self.remove_item(item)
item.delete()
def purge(self):
for item in self.items:
item.delete()
class DataHistory(Entity):
using_options(tablename='history', order_by='-when')
when = Field(DateTime)
action = Field(Unicode(255))
data = Field(JSONType)
board = ManyToOne('DataBoard', ondelete='cascade')
card = ManyToOne('DataCard', ondelete='cascade')
user = ManyToOne('DataUser', ondelete='cascade')
def to_string(self):
data = self.data.copy()
data['author'] = self.user.fullname or self.user.username
return render_event(self.action, data)
@classmethod
def add_history(cls, board, card, user, action, data):
data.update(action=action)
when = datetime.utcnow()
data = cls(when=when,
action=action,
board=board,
card=card,
user=user,
data=data)
database.session.flush()
@classmethod
def get_events(cls, board, hours=None):
'''board to None means "everything".'''
since = datetime.utcnow() - timedelta(hours=hours)
q = cls.query
if board:
q = q.filter_by(board=board)
q = q.filter(cls.when >= since)
q = q.order_by(cls.board_id, cls.action, cls.when)
return q.all()
@classmethod
def get_history(cls, board, cardid=None, username=None):
q = cls.query
q = q.filter_by(board=board)
if cardid:
q = q.filter(cls.card.has(id=cardid))
if username:
q = q.filter(cls.user.has(username=username))
return q
@classmethod
def get_last_activity(cls, board):
q = database.session.query(cls.when)
q = q.filter(cls.board == board)
q = q.order_by(cls.when.desc())
q = q.limit(1)
return q.scalar()
class DataHistory(Entity):
using_options(tablename='history', order_by='-when')
when = Field(DateTime)
action = Field(Unicode(255))
data = Field(JSONType)
board = ManyToOne('DataBoard', ondelete='cascade')
card = ManyToOne('DataCard', ondelete='cascade')
user = ManyToOne('DataUser', ondelete='cascade')
class nmap_script(Entity):
script_id = Field(String)
output = Field(Unicode)
port = ManyToOne('nmap_port')
host = ManyToOne('nmap_host')
def __init__(self, script_id, output, portId, hostId):
self.script_id = script_id
self.output = unicode(output)
self.port = portId
self.host = hostId
class DataCardMembership(Entity):
using_options(tablename='membership_cards__card')
membership = ManyToOne('DataMembership', ondelete='cascade', required=True)
card = ManyToOne('DataCard', ondelete='cascade', required=True)
using_table_options(
sa.UniqueConstraint('membership_id',
'card_id',
name='card_membership_ix'))
@classmethod
def purge(cls, card):
for member in cls.query.filter_by(card=card):
member.delete()
class Sequence(Entity):
accession_obj = ManyToOne('Accession', colname='accession')
alignment_obj = ManyToOne('Alignment', colname='alignment')
start = Field(Integer)
bases = Field(Text)
quality = Field(Text)
_quality = Field(Text)
created = Field(DateTime, default=datetime.now)
modified = Field(DateTime)
using_options(tablename='sequence',
metadata=__metadata__,
session=__session__)
using_table_options(mysql_engine='InnoDB')
class SNPs2SNPset(Entity):
snp = ManyToOne('SNPs',
colname='snps_id',
ondelete='CASCADE',
onupdate='CASCADE')
snpset = ManyToOne('SNPset',
colname='snpset_id',
ondelete='CASCADE',
onupdate='CASCADE')
using_options(tablename='snps2snpset',
metadata=__metadata__,
session=__session__)
using_table_options(mysql_engine='InnoDB')
class Accession(Entity):
population_obj = ManyToOne('Population', colname='population')
region_obj = ManyToOne('Region', colname='region')
description = Field(Text)
name = Field(String(20))
origin = Field(String(50))
created = Field(DateTime, default=datetime.now)
modified = Field(DateTime)
number = Field(String(10))
using_options(tablename='accession',
metadata=__metadata__,
session=__session__)
using_table_options(mysql_engine='InnoDB')
class nmap_port(Entity):
port_id = Field(String)
protocol = Field(String)
state = Field(String)
host = ManyToOne('nmap_host')
service = ManyToOne('nmap_service')
script = ManyToMany('nmap_script')
def __init__(self, port_id, protocol, state, host, service=''):
self.port_id = port_id
self.protocol = protocol
self.state = state
self.host = host
self.service = service
class BatchEcotype(Entity):
batch = ManyToOne('Batch',
colname='batchid',
ondelete='CASCADE',
onupdate='CASCADE')
ecotype = ManyToOne('Ecotype',
colname='ecotypeid',
ondelete='CASCADE',
onupdate='CASCADE')
lineorder = Field(Integer, nullable=False)
using_options(tablename='batch_ecotype',
metadata=__metadata__,
session=__session__)
using_table_options(mysql_engine='InnoDB')
class Constraint(Entity):
using_options(tablename='constraints')
caption = Field(Text,
default='Constraint') #Constraint name (specified by PI)
type = Field(Text) #Module providing constraint logic
min = Field(Float, default=0) #Minimum value passed to constraint logic
max = Field(Float, default=0) #Maximum value passed to constraint logic
exposure = ManyToOne('Exposure', inverse='constraints')
observation = ManyToOne('Observation', inverse='constraints')
program = ManyToOne('Program', inverse='constraints')
def checkMe(self):
return True
class Cast(Entity):
using_options(tablename='cast')
movie = ManyToOne('Movie')
actor = ManyToOne('Person', required=True)
role = Field(Unicode(60))
class Admin(EntityAdmin):
verbose_name = 'Actor'
list_display = ['actor', 'role']
form_display = ['actor', 'role']
def __unicode__(self):
if self.actor:
return self.actor.name
return ''
class Station(Entity):
name = Field(String(256))
url = Field(String(256))
bitrate = ManyToOne('Bitrate')
stream = ManyToOne('Stream')
genres = ManyToMany('Genre')
def __init__(self, **kwars):
for key, value in kwars.items():
setattr(self, key, value)
def __repr__(self):
return '<Station %s>' % (self.name)
class Lei(Entity):
using_options(tablename='lei_decisao')
esfera = Field(Unicode(10))
lei = Field(Unicode(32))
ano = Field(Integer)
decisao = ManyToOne('Decisao')
artigos = OneToMany('Artigo')
class DataChecklistItem(Entity):
using_options(tablename='checklist_items')
index = Field(Integer)
title = Field(Unicode(255))
done = Field(Boolean)
checklist = ManyToOne('DataChecklist')
class note(Entity):
host = ManyToOne('nmap_host')
text = Field(Unicode)
def __init__(self, hostId, text):
self.text = unicode(text)
self.host = hostId
class DataCard(Entity):
'''Card mapper'''
using_options(tablename='card')
title = Field(UnicodeText)
index = Field(Integer)
creation_date = Field(DateTime, default=datetime.datetime.utcnow)
column = ManyToOne('DataColumn')
# feature data to move to card extensions
members = ManyToMany('DataUser')
def update(self, other):
self.title = other.title
self.index = other.index
session.flush()
# Methods for data belonging to card extensions
def remove_member(self, datauser):
if datauser in self.members:
self.members.remove(datauser)
@property
def archived(self):
return self.column.archive
class DataLabel(Entity):
"""Label mapper
"""
using_options(tablename='label')
title = Field(Unicode(255))
color = Field(Unicode(255))
board = ManyToOne('DataBoard')
cards = ManyToMany('DataCard', tablename='label_cards__card_labels')
index = Field(Integer)
def copy(self, parent):
new_data = DataLabel(title=self.title,
color=self.color,
index=self.index,
board=parent)
session.flush()
return new_data
@classmethod
def get_by_card(cls, card):
q = cls.query
q = q.filter(cls.cards.contains(card))
return q.all()
@classmethod
def add_to_card(cls, card, id):
label = cls.get(id)
if not card in label.cards:
label.cards.append(card)
@classmethod
def remove_from_card(cls, card, id):
label = cls.get(id)
if card in label.cards:
label.cards.remove(card)
class DataLabel(Entity):
"""Label mapper
"""
using_options(tablename='label')
title = Field(Unicode(255))
color = Field(Unicode(255))
board = ManyToOne('DataBoard')
cards = ManyToMany('DataCard', tablename='label_cards__card_labels')
index = Field(Integer)
def copy(self):
new_data = DataLabel(title=self.title,
color=self.color,
index=self.index)
return new_data
def remove(self, card):
self.cards.remove(card)
def add(self, card):
self.cards.append(card)
@classmethod
def get_by_card(cls, card):
q = cls.query
q = q.filter(cls.cards.contains(card))
return q.order_by(cls.index)
class HaploGroup(Entity):
"""
2009-3-30
table to store the haplotype groups generated from Alex
"""
short_name = Field(String(40), unique=True)
ref_ecotype = ManyToOne(
"Ecotype",
colname='ref_ecotypeid',
ondelete='CASCADE',
onupdate='CASCADE') #the ecotype with the best reference genotype.
latitude = Field(Float)
longitude = Field(Float)
max_snp_typing_error_rate = Field(Float)
comment = Field(String(8192))
ecotypes = ManyToMany("Ecotype",
tablename='haplo_group2ecotype',
ondelete='CASCADE',
onupdate='CASCADE')
created_by = Field(String(200))
updated_by = Field(String(200))
date_created = Field(DateTime, default=datetime.now)
date_updated = Field(DateTime)
using_options(tablename='haplo_group',
metadata=__metadata__,
session=__session__)
using_table_options(mysql_engine='InnoDB')
using_table_options(UniqueConstraint('short_name', 'ref_ecotypeid'))
class ComiteNews(Entity):
"""Mapper for the `comite` news, sent by users"""
using_options(tablename='comite_news')
user = ManyToOne('User')
creation_date = Field(DateTime, default=datetime.now)
title = Field(String(500,convert_unicode=True))
content = Field(Text(convert_unicode=True))
class DataComment(Entity):
"""Comment mapper
"""
using_options(tablename='comment')
comment = Field(UnicodeText, default=u'')
creation_date = Field(DateTime)
card = ManyToOne('DataCard')
author = ManyToOne('DataUser')
@classmethod
def get_by_card(cls, card):
q = cls.query
q = q.filter_by(card=card)
q = q.order_by(cls.creation_date.desc())
return q.all()