class Category(db.Model):
id = db.Column(db.Integer, primary_key=True, nullable=False)
name = db.Column(db.Text, nullable=False)
description = db.Column(db.Text, nullable=False)
active = db.Column(db.Boolean, default=True, nullable=False)
annotators = db.relationship('AnnotatorCategory', cascade="all,delete")
items = db.relationship('ItemCategory', cascade="all,delete")
def __init__(self, name, description):
self.name = name
self.description = description
@classmethod
def by_id(cls, uid):
if uid is None:
return None
try:
item = cls.query.get(uid)
except NoResultFound:
item = None
return item
@classmethod
def by_name_or_id(cls, uid):
category = cls.by_id(uid)
if category:
return category
try:
return cls.query.filter(cls.name == uid).first()
except NoResultFound:
return None
class Setting(db.Model):
key = db.Column(db.Text, unique=True, nullable=False, primary_key=True)
value = db.Column(db.Text, nullable=False)
def __init__(self, key, value):
self.key = key
self.value = value
@classmethod
def by_key(cls, key):
try:
setting = cls.query.filter(cls.key == key).one()
except NoResultFound:
setting = None
return setting
@classmethod
def value_of(cls, key):
setting = cls.by_key(key)
if setting:
return setting.value
else:
return None
@classmethod
def set(cls, key, value):
setting = cls.by_key(key)
if setting:
setting.value = value
else:
setting = cls(key, value)
db.session.add(setting)
class Item(db.Model):
id = db.Column(db.Integer, primary_key=True, nullable=False)
name = db.Column(db.Text, nullable=False)
location = db.Column(db.Text, nullable=False)
description = db.Column(db.Text, nullable=False)
active = db.Column(db.Boolean, default=True, nullable=False)
categories = db.relationship('ItemCategory', cascade="all,delete")
def __init__(self, name, location, description, *categories):
self.name = name
self.location = location
self.description = description
self.categories = [
ItemCategory(-1, Category.by_name_or_id(category).id)
for category in categories
]
def get_category(self, category_id):
for category in self.categories:
if category.category_id == int(category_id):
return category
@classmethod
def by_id(cls, uid):
if uid is None:
return None
try:
item = cls.query.get(uid)
except NoResultFound:
item = None
return item
class Item(db.Model):
id = db.Column(db.Integer, primary_key=True, nullable=False)
name = db.Column(db.Text, nullable=False)
location = db.Column(db.Text, nullable=False)
youtube_url = db.Column(db.Text, nullable=False)
description = db.Column(db.Text, nullable=False)
active = db.Column(db.Boolean, default=True, nullable=False)
viewed = db.relationship('Annotator', secondary=view_table)
prioritized = db.Column(db.Boolean, default=False, nullable=False)
mu = db.Column(db.Float)
sigma_sq = db.Column(db.Float)
NUM_EDITABLE_FIELDS = 4
def __init__(self, name, location, youtube_url, description):
self.name = name
self.location = location
self.youtube_url = youtube_url
self.description = description
self.mu = crowd_bt.MU_PRIOR
self.sigma_sq = crowd_bt.SIGMA_SQ_PRIOR
@classmethod
def by_id(cls, uid):
if uid is None:
return None
try:
item = cls.query.get(uid)
except NoResultFound:
item = None
return item
class Item(db.Model):
id = db.Column(db.Integer, primary_key=True, nullable=False)
name = db.Column(db.Text, nullable=False)
location = db.Column(db.Text, nullable=False)
description = db.Column(db.Text, nullable=False)
active = db.Column(db.Boolean, default=True, nullable=False)
viewed = db.relationship('Annotator', secondary=view_table)
prioritized = db.Column(db.Boolean, default=False, nullable=False)
mu = db.Column(db.Float)
sigma_sq = db.Column(db.Float)
def __init__(self, name, location, description):
self.name = name
self.location = location
self.description = description
self.mu = crowd_bt.MU_PRIOR
self.sigma_sq = crowd_bt.SIGMA_SQ_PRIOR
@classmethod
def by_id(cls, uid):
if uid is None:
return None
try:
item = cls.query.get(uid)
except NoResultFound:
item = None
return item
def getVideoPreviewURL(self):
# try and convert to video preview
return 'https://drive.google.com/file/d/' + parse_qs(
urlparse(self.location).query)['id'][0] + '/preview'
class Decision(db.Model):
id = db.Column(db.Integer, primary_key=True, nullable=False)
annotator_id = db.Column(db.Integer, db.ForeignKey('annotator.id'))
annotator = db.relationship('Annotator', foreign_keys=[annotator_id], uselist=False)
winner_id = db.Column(db.Integer, db.ForeignKey('item.id'))
winner = db.relationship('Item', foreign_keys=[winner_id], uselist=False)
loser_id = db.Column(db.Integer, db.ForeignKey('item.id'))
loser = db.relationship('Item', foreign_keys=[loser_id], uselist=False)
time = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
def __init__(self, annotator, winner, loser):
self.annotator = annotator
self.winner = winner
self.loser = loser
class Flag(BaseModel):
id = db.Column(db.Integer, primary_key=True, nullable=False)
annotator_id = db.Column(db.Integer, db.ForeignKey('annotator.id'))
annotator = db.relationship('Annotator',
foreign_keys=[annotator_id],
uselist=False)
item_id = db.Column(db.Integer, db.ForeignKey('item.id'))
item = db.relationship('Item', foreign_keys=[item_id], uselist=False)
reason = db.Column(db.Text, nullable=False)
resolved = db.Column(db.Boolean, default=False, nullable=False)
time = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
_default_fields = ["annotator_id", "item_id", "reason", "resolved", "time"]
relations_keys = ("item", "annotator")
def __init__(self, annotator, item, reason):
self.annotator = annotator
self.item = item
self.reason = reason
def __repr__(self):
return '<Flag %r>' % self.id
@classmethod
def by_id(cls, uid):
if uid is None:
return None
try:
flag = cls.query.with_for_update().get(uid)
except NoResultFound:
flag = None
return flag
class ItemCategory(db.Model):
id = db.Column('id', db.Integer, primary_key=True)
item_id = db.Column(db.Integer, db.ForeignKey('item.id'))
category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
mu = db.Column(db.Float)
sigma_sq = db.Column(db.Float)
prioritized = db.Column(db.Boolean, default=False, nullable=False)
viewed = db.relationship('Annotator', secondary=view_table)
item = db.relationship('Item')
category = db.relationship('Category')
def __init__(self, item_id, category_id):
self.item_id = item_id
self.category_id = category_id
self.mu = crowd_bt.MU_PRIOR
self.sigma_sq = crowd_bt.SIGMA_SQ_PRIOR
@classmethod
def by_id(cls, uid):
if uid is None:
return None
try:
annotator = cls.query.with_for_update().get(uid)
except NoResultFound:
annotator = None
return annotator
class Item(BaseModel):
id = db.Column(db.Integer, primary_key=True, nullable=False)
name = db.Column(db.Text, nullable=False)
location = db.Column(db.Text, nullable=False)
description = db.Column(db.Text, nullable=False)
active = db.Column(db.Boolean, default=True, nullable=False)
viewed = db.relationship('Annotator', secondary=view_table)
prioritized = db.Column(db.Boolean, default=False, nullable=False)
flags = db.relationship('Flag', back_populates="item")
mu = db.Column(db.Float)
sigma_sq = db.Column(db.Float)
_default_fields = [
"name", "location", "description", "active", "seen", "prioritized",
"mu", "sigma_sq"
]
relations_keys = ("viewed", "flags")
def __init__(self, name, location, description):
self.name = name
self.location = location
self.description = description
self.mu = crowd_bt.MU_PRIOR
self.sigma_sq = crowd_bt.SIGMA_SQ_PRIOR
@property
def seen(self):
return len(self.viewed)
@classmethod
def by_id(cls, uid):
if uid is None:
return None
try:
item = cls.query.get(uid)
except NoResultFound:
item = None
return item
class Feedback(db.Model):
id = db.Column(db.Integer, primary_key=True, nullable=False)
annotator_id = db.Column(db.Integer, db.ForeignKey('annotator.id'))
annotator = db.relationship('Annotator',
foreign_keys=[annotator_id],
uselist=False)
item_id = db.Column(db.Integer, db.ForeignKey('item.id'))
item = db.relationship('Item', foreign_keys=[item_id], uselist=False)
feedback_type = db.Column(db.String(10))
feedback = db.Column(db.String(250))
time = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
def __init__(self, annotator, item, feedback_type, feedback):
self.annotator = annotator
self.item = item
self.feedback_type = feedback_type
self.feedback = feedback
from gavel.models import db
import gavel.crowd_bt as crowd_bt
from sqlalchemy.orm.exc import NoResultFound
from urllib.parse import urlparse
from urllib.parse import parse_qs
view_table = db.Table(
'view', db.Column('item_id', db.Integer, db.ForeignKey('item.id')),
db.Column('annotator_id', db.Integer, db.ForeignKey('annotator.id')))
class Item(db.Model):
id = db.Column(db.Integer, primary_key=True, nullable=False)
name = db.Column(db.Text, nullable=False)
location = db.Column(db.Text, nullable=False)
description = db.Column(db.Text, nullable=False)
active = db.Column(db.Boolean, default=True, nullable=False)
viewed = db.relationship('Annotator', secondary=view_table)
prioritized = db.Column(db.Boolean, default=False, nullable=False)
mu = db.Column(db.Float)
sigma_sq = db.Column(db.Float)
def __init__(self, name, location, description):
self.name = name
self.location = location
self.description = description
self.mu = crowd_bt.MU_PRIOR
self.sigma_sq = crowd_bt.SIGMA_SQ_PRIOR
@classmethod
class Annotator(db.Model):
id = db.Column(db.Integer, primary_key=True, nullable=False)
name = db.Column(db.String(120), nullable=False)
email = db.Column(db.String(120), nullable=False)
active = db.Column(db.Boolean, default=True, nullable=False)
read_welcome = db.Column(db.Boolean, default=False, nullable=False)
description = db.Column(db.Text, nullable=False)
secret = db.Column(db.String(32), unique=True, nullable=False)
next_id = db.Column(db.Integer, db.ForeignKey('item.id'))
next = db.relationship('Item', foreign_keys=[next_id], uselist=False)
updated = db.Column(db.DateTime)
prev_id = db.Column(db.Integer, db.ForeignKey('item.id'))
prev = db.relationship('Item', foreign_keys=[prev_id], uselist=False)
ignore = db.relationship('Item', secondary=ignore_table)
alpha = db.Column(db.Float)
beta = db.Column(db.Float)
def __init__(self, name, email, description):
self.name = name
self.email = email
self.description = description
self.alpha = crowd_bt.ALPHA_PRIOR
self.beta = crowd_bt.BETA_PRIOR
self.secret = utils.gen_secret(32)
def update_next(self, new_next):
if new_next is not None:
new_next.prioritized = False # it's now assigned, so cancel the prioritization
# it could happen that the judge skips the project, but that
# doesn't re-prioritize the project
self.updated = datetime.utcnow()
self.next = new_next
@classmethod
def by_secret(cls, secret):
try:
annotator = cls.query.filter(cls.secret == secret).one()
except NoResultFound:
annotator = None
return annotator
@classmethod
def by_name(cls, name):
try:
annotator = cls.query.filter(cls.name == name).one()
except NoResultFound:
annotator = None
return annotator
@classmethod
def by_id(cls, uid):
if uid is None:
return None
try:
annotator = cls.query.with_for_update().get(uid)
except NoResultFound:
annotator = None
return annotator
class Item(db.Model):
id = db.Column(db.Integer, primary_key=True, nullable=False)
name = db.Column(db.Text, nullable=False, unique=True) # team name
location = db.Column(db.Text, nullable=False, unique=True) # Seat alloted
secret_key = db.Column(db.Text, nullable=False, unique=True) # Alloted secret key
title = db.Column(db.Text, default="", nullable=False) # Project Title
description = db.Column(db.Text, default="", nullable=False) # Project description
demo_link = db.Column(db.Text, default="", nullable=False) # Project demo video
git_link = db.Column(db.Text, default="", nullable=False) # Github repo link for the project
inspiration = db.Column(db.Text, default="", nullable=False) # Project Inspiration
how_built = db.Column(db.Text, default="", nullable=False) # Project build description
challenges = db.Column(db.Text, default="", nullable=False) # Challenges faced
accomplishments = db.Column(db.Text, default="", nullable=False) # Accomplishments
learned = db.Column(db.Text, default="", nullable=False) # What learned
next = db.Column(db.Text, default="", nullable=False) # What's next
built_with = db.Column(db.Text, default="", nullable=False) # Technologies used
active = db.Column(db.Boolean, default=True, nullable=False)
viewed = db.relationship('Annotator', secondary=view_table)
prioritized = db.Column(db.Boolean, default=False, nullable=False)
submitted = db.Column(db.Boolean, default=False, nullable=False) # Project Submitted
mu = db.Column(db.Float)
sigma_sq = db.Column(db.Float)
def __init__(self, name, location, secret_key):
self.name = name
self.location = location
self.secret_key = secret_key
self.mu = crowd_bt.MU_PRIOR
self.sigma_sq = crowd_bt.SIGMA_SQ_PRIOR
@classmethod
def by_id(cls, uid):
if uid is None:
return None
try:
item = cls.query.get(uid)
except NoResultFound:
item = None
return item
class Item(db.Model):
id = db.Column(db.Integer, primary_key=True, nullable=False)
name = db.Column(db.Text, nullable=False)
location = db.Column(db.Text, nullable=False)
floor = db.Column(db.Text, nullable=False)
description = db.Column(db.Text, nullable=False)
url = db.Column(db.Text, nullable=False)
categories = db.Column(db.Text, nullable=False)
active = db.Column(db.Boolean, default=True, nullable=False)
viewed = db.relationship('Annotator', secondary=view_table)
prioritized = db.Column(db.Boolean, default=False, nullable=False)
mu = db.Column(db.Float)
sigma_sq = db.Column(db.Float)
def __init__(self, name, location, url, description, categories):
self.name = name
self.location, self.floor = self.calculate_initial_floor(location)
self.url = url
self.description = description
self.categories = categories
self.mu = crowd_bt.MU_PRIOR
self.sigma_sq = crowd_bt.SIGMA_SQ_PRIOR
def calculate_initial_floor(self, location):
try:
table = int(location)
except:
return "TBD", "TBD"
if table <= 125:
return str(table), "basement"
elif table <= 162: # 301-337
return str(table - 125 + 300), "basement"
else: # 401-XXX
return str(table - 162 + 400), "outside"
def get_categories(self):
return [
category.strip() for category in (self.categories or "").split(",")
if category.strip() != ""
]
@classmethod
def by_id(cls, uid):
if uid is None:
return None
try:
item = cls.query.get(uid)
except NoResultFound:
item = None
return item
from gavel.models import db
from gavel.models.category import Category
import gavel.crowd_bt as crowd_bt
from sqlalchemy.orm.exc import NoResultFound
view_table = db.Table('view',
db.Column('item_category_id', db.Integer, db.ForeignKey('item_category.id')),
db.Column('annotator_id', db.Integer, db.ForeignKey('annotator.id'))
)
class ItemCategory(db.Model):
id = db.Column('id', db.Integer, primary_key=True)
item_id = db.Column(db.Integer, db.ForeignKey('item.id'))
category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
mu = db.Column(db.Float)
sigma_sq = db.Column(db.Float)
prioritized = db.Column(db.Boolean, default=False, nullable=False)
viewed = db.relationship('Annotator', secondary=view_table)
item = db.relationship('Item')
category = db.relationship('Category')
def __init__(self, item_id, category_id):
self.item_id = item_id
self.category_id = category_id
self.mu = crowd_bt.MU_PRIOR
self.sigma_sq = crowd_bt.SIGMA_SQ_PRIOR
@classmethod
def by_id(cls, uid):
class Item(BaseModel):
id = db.Column(db.Integer, primary_key=True, nullable=False)
name = db.Column(db.Text, nullable=False)
location = db.Column(db.Text, nullable=False)
description = db.Column(db.Text, nullable=False)
# Optional Video Reference (implicitly "required" in "virtual mode")
video_reference = db.Column(db.Text, nullable=True)
# Optional Submission Reference (implicitly "required" in "virtual mode")
submission_reference = db.Column(db.Text, nullable=True)
# Optional Tagline (implicitly "required" in "virtual mode")
tagline = db.Column(db.Text, nullable=True)
# Optional Submission Website Reference (implicitly "required" in "virtual mode")
submission_website = db.Column(db.Text, nullable=True)
active = db.Column(db.Boolean, default=True, nullable=False)
viewed = db.relationship('Annotator', secondary=view_table)
prioritized = db.Column(db.Boolean, default=False, nullable=False)
flags = db.relationship('Flag', back_populates="item")
updated = db.Column(db.DateTime, onupdate=datetime.utcnow)
mu = db.Column(db.Float)
sigma_sq = db.Column(db.Float)
_default_fields = [
"name", "location", "description", "video_reference",
"submission_reference", "submission_website", "tagline", "active",
"seen", "prioritized", "mu", "sigma_sq", "updated"
]
relations_keys = ("viewed", "flags")
def __init__(self,
name,
location,
description,
tagline="N/A",
video_reference="N/A",
submission_reference="N/A",
submission_website="N/A"):
self.name = name
self.location = location
self.description = description
self.tagline = tagline
self.video_reference = video_reference
self.submission_reference = submission_reference
self.submission_website = submission_website
self.mu = crowd_bt.MU_PRIOR
self.sigma_sq = crowd_bt.SIGMA_SQ_PRIOR
# @validates('tagline')
# def require_tagline_on_virtual(self, key, tagline):
# if settings.VIRTUAL_EVENT:
# assert tagline
# return tagline
# @validates('video_reference')
# def require_video_reference_on_virtual(self, key, video_reference):
# if settings.VIRTUAL_EVENT:
# assert video_reference
# return video_reference
# @validates('submission_reference')
# def require_submission_reference_on_virtual(self, key, submission_reference):
# if settings.VIRTUAL_EVENT:
# assert submission_reference
# return submission_reference
# @validates('submission_website')
# def require_submission_website_on_virtual(self, key, submission_website):
# if settings.VIRTUAL_EVENT:
# assert submission_website
# return submission_website
@property
def seen(self):
return len(self.viewed)
@classmethod
def by_id(cls, uid):
if uid is None:
return None
try:
item = cls.query.get(uid)
except NoResultFound:
item = None
return item
