class Dataset(db.Model):
__tablename__ = "datasets"
id = db.Column(db.Integer, primary_key=True)
bucket_name = db.Column(db.String(255))
folder_name = db.Column(db.String(255))
object_name = db.Column(db.String(255))
file_name = db.Column(db.String(255))
project_id = db.Column(db.Integer, db.ForeignKey("projects.id"), nullable=False)
project = db.relationship("Project")
def __init__(self, bucket_name, folder_name, object_name, file_name, project_id):
self.bucket_name = bucket_name
self.folder_name = folder_name
self.object_name = object_name
self.file_name = file_name
self.project_id = project_id
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
def get_data_path(self):
return f"s3://{self.bucket_name}/{self.folder_name}/train"
@classmethod
def find_data_by_id(cls, data_id):
return cls.query.filter_by(id=data_id).first()
class Project(db.Model):
__tablename__ = "projects"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255))
location_name = db.Column(
db.String(255)) # This denotes the project location name in s3 bucket
description = db.Column(db.String(255))
type = db.Column(db.String(255))
user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
def __init__(self, name, description, type, user_id):
self.name = name
self.description = description
self.type = type
self.user_id = user_id
self.generate_location_name()
def generate_location_name(self):
# Generate a unique uuid string
self.location_name = uuid4().hex
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
def belongs_to_user(self, user_id):
return self.user_id == user_id
def json(self):
return {
"id": self.id,
"name": self.name,
"location_name": self.location_name,
"description": self.description,
"type": self.type
}
@classmethod
def find_project_with_id(cls, project_id):
return cls.query.filter_by(id=project_id).first()
@classmethod
def find_project_from_user(cls, user_id):
return cls.query.filter_by(user_id=user_id).all()
def is_classification_problem(self):
return self.type == "classification"
def is_regression_problem(self):
return self.type == "regression"
class NotebookModel(db.Model):
__tablename__ = "notebooks"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), nullable=False)
status = db.Column(db.String(20))
user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
def __init__(self, name, status, user_id):
self.name = name
self.status = status
self.user_id = user_id
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.remove(self)
db.session.commit()
def json(self):
return {
"id": self.id,
"name": self.name,
"status": self.status,
"user_id": self.user_id
}
def update_status(self, status):
self.status = status
self.save()
@classmethod
def find_by_id(cls, id):
return cls.query.filter_by(id=id).first()
@classmethod
def find_by_user_id(cls, user_id):
return cls.query.filter_by(user_id=user_id).all()
@classmethod
def find_by_name(cls, name):
return cls.query.filter_by(name=name).first()
def is_in_terminal_state(self):
return self.status in ["Failed", "InService", "Stopped"]
class UserModel(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(255), nullable=False)
email = db.Column(db.String(255), nullable=False)
tokens = db.Column(db.Integer, default=0)
_password = db.Column(db.String(255), nullable=False)
@hybrid_property
def password(self):
return self._password
@password.setter
def password(self, plaintext):
self._password = bcrypt.generate_password_hash(plaintext).decode(
'utf-8')
def save(self):
db.session.add(self)
db.session.commit()
def increase_tokens(self, tokens):
self.tokens += tokens
self.save()
def delete(self):
db.session.delete(self)
db.session.commit()
def check_password(self, plaintext):
return bcrypt.check_password_hash(self._password, plaintext)
def json(self):
return {
"email": self.email,
"username": self.username,
"tokens": self.tokens
}
@classmethod
def find_user_with_id(cls, user_id):
return cls.query.filter_by(id=user_id).first()
@classmethod
def find_user_with_email(cls, email):
return cls.query.filter_by(email=email).first()
class QuizModel(database.Model):
__tablename__ = 'quizzes'
quiz_id = database.Column(database.Integer, primary_key=True, nullable=False)
test_id = database.Column(database.Integer, database.ForeignKey('tests.test_id'), nullable=False)
order_num = database.Column(database.Integer, nullable=False)
credit_value = database.Column(database.Integer, nullable=False)
gained_credit = database.Column(database.Integer)
quiz_type = database.Column(database.String)
text_body = database.Column(database.String)
path_to_attachment = database.Column(database.String)
title = database.Column(database.String(100))
instructions = database.Column(database.String)
test = database.relationship('TestModel')
answers = database.relationship('AnswerModel', lazy='dynamic')
def __init__(self, quiz_id, test_id, order_num, credit_value, gained_credit, quiz_type, text_body, path_to_attachment, title, instructions):
self.quiz_id = quiz_id
self.test_id = test_id
self.order_num = order_num
self.credit_value = credit_value
self.gained_credit = gained_credit
self.quiz_type = quiz_type # 'type' is a key word in Python
self.text_body = text_body
self.path_to_attachment = path_to_attachment
self.title = title
self.instructions = instructions
def json(self, getCorrectAnswers=False):
return {
'quiz_id': self.quiz_id,
'test_id': self.test_id,
'order_num': self.order_num,
'credit_value': self.credit_value,
'gained_credit': self.gained_credit,
'quiz_type': self.quiz_type,
'text_body': self.text_body,
'path_to_attachment': self.path_to_attachment,
'title': self.title,
'instructions': self.instructions,
'answers': [a.json(getCorrectAnswers=getCorrectAnswers) for a in self.answers.all()]
}
def save_to_database(self):
database.session.add(self)
database.session.commit()
def delete_from_database(self):
database.session.delete(self)
database.session.commit()
def get_correct_answer(self):
return self.answers.filter_by(quiz_id=self.quiz_id, is_correct=True).first()
@classmethod
def find_by_id(cls, quiz_id):
return cls.query.filter_by(quiz_id=quiz_id).first()
class UserModel(database.Model):
__tablename__ = 'users'
id = database.Column(database.Integer, primary_key=True)
username = database.Column(database.String(80))
password = database.Column(database.String(80))
puzzles = database.relationship('PuzzleModel', lazy='dynamic')
def __init__(self, username, password):
self.username = username
self.password = password
def to_json(self):
return {'id': self.id, 'username': self.username}
def to_json_score(self):
lst = [p.to_json().get('score') for p in self.puzzles.all()]
return {
'id': self.id,
'username': self.username,
'scores': lst,
'total_score': sum(lst) # reduce(add, lst, 0) # fold_left
}
@classmethod
def find_by_username(cls, username):
return cls.query.filter_by(username=username).first()
@classmethod
def find_by_id(cls, user_id):
return cls.query.filter_by(id=user_id).first()
def save_to_db(self):
database.session.add(self)
database.session.commit()
def update_to_db(self, pwd):
self.password = pwd
database.session.commit()
def delete_from_db(self):
database.session.delete(self)
database.session.commit()
class PaymentModel(db.Model):
__tablename__ = "payments"
id = db.Column(db.Integer, primary_key=True)
type = db.Column(db.String(20), nullable=False)
price = db.Column(db.Float, nullable=False)
amount = db.Column(db.Integer, nullable=False)
@classmethod
def find_by_id(cls, id):
return cls.query.filter_by(id=id).first()
class DeploymentModel(db.Model):
__tablename__ = "deployments"
id = db.Column(db.Integer, primary_key=True)
project_id = db.Column(db.Integer,
db.ForeignKey("projects.id"),
nullable=False)
endpoint_name = db.Column(db.String(255), nullable=False)
status = db.Column(db.String(255), default="Creating")
def __init__(self, project_id, endpoint_name):
self.project_id = project_id
self.endpoint_name = endpoint_name
self.status = "Creating"
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
def json(self):
return {
"id": self.id,
"project_id": self.project_id,
"endpoint_name": self.endpoint_name,
"status": self.status
}
def update_status(self, status):
self.status = status
self.save()
@classmethod
def find_by_project_id(cls, project_id):
return cls.query.filter_by(project_id=project_id).first()
@classmethod
def if_a_deployment_exist(cls, project_id):
return cls.query.filter_by(project_id=project_id).first() != None
class TopicModel(database.Model):
__tablename__ = 'topics'
topic_id = database.Column(database.Integer,
primary_key=True,
nullable=False)
is_unlocked = database.Column(database.Boolean, nullable=False)
name = database.Column(database.String(50), nullable=False)
needed_credit = database.Column(database.Integer)
tests = database.relationship('TestModel', lazy='dynamic')
formativeAssessments = database.relationship('FormativeAssessmentModel',
lazy='dynamic')
def __init__(self, topic_id, is_unlocked, name, needed_credit):
self.topic_id = topic_id
self.is_unlocked = is_unlocked
self.name = name
self.needed_credit = needed_credit
def json(self):
return {
'topic_id':
self.topic_id,
'is_unlocked':
self.is_unlocked,
'name':
self.name,
'needed_credit':
self.needed_credit,
'tests': [t.json() for t in self.tests.all()],
'formative_assessments':
[fa.json() for fa in self.formativeAssessments.all()]
}
def save_to_database(self):
database.session.add(self)
database.session.commit()
def delete_from_database(self):
database.session.delete(self)
database.session.commit()
@classmethod
def find_by_id(cls, topic_id):
return cls.query.filter_by(topic_id=topic_id).first()
@classmethod
def get_all(cls):
return cls.query.all()
class UserModel(database.Model):
__tablename__ = 'user'
first_name = database.Column(database.String(60))
last_name = database.Column(database.String(60))
date_of_birth = database.Column(database.String(10))
address = database.Column(database.String(100))
contact_no = database.Column(database.Integer)
email = database.Column(database.String(80))
qualification = database.Column(database.String(80))
gender = database.Column(database.String(80))
salary = database.Column(database.Integer)
pan_no = database.Column(database.String(80))
type_of_employer = database.Column(database.String(100))
name_of_employer = database.Column(database.String(100))
user_id = database.Column(database.String(100), primary_key=True)
password = database.Column(database.String(100))
def __init__(self, first_name, last_name, date_of_birth, address, contact_no, email, qualification, gender, salary,
pan_no, type_of_employer, name_of_employer, user_id, password):
self.first_name = first_name
self.last_name = last_name
self.date_of_birth = date_of_birth
self.address = address
self.contact_no = contact_no
self.email = email
self.qualification = qualification
self.gender = gender
self.salary = salary
self.pan_no = pan_no
self.type_of_employer = type_of_employer
self.name_of_employer = name_of_employer
self.user_id = user_id
self.password = password
def json(self):
return {'first_name': self.first_name,
'last_name': self.last_name,
'date_of_birth': self.date_of_birth,
'address': self.address,
'contact_no': self.contact_no,
'email': self.email,
'qualification': self.qualification,
'gender': self.gender,
'salary': self.salary,
'pan_no': self.pan_no,
'type_of_employer': self.type_of_employer,
'name_of_employer': self.name_of_employer,
'user_id': self.user_id,
'password': self.password
}
@classmethod
def find_by_email(cls, email):
return cls.query.filter_by(email=email).first()
@classmethod
def find_by_password(cls, password):
return cls.query.filter_by(password=password).first()
@classmethod
def find_by_login(cls, user_id, password):
return cls.query.filter_by(user_id=user_id, password=password).first()
@classmethod
def find_by_user_id(cls, user_id):
return cls.query.filter_by(user_id=user_id).first()
def save_to_database(self):
database.session.add(self)
database.session.commit()
def delete_from_database(self):
database.session.delete(self)
database.session.commit()
def generate_auth_token(self, expiration=600):
s = Serializer(app.config['SECRET_KEY'], expires_in=expiration)
return s.dumps({'id': self.id})
@staticmethod
def verify_auth_token(token):
app = Flask(__name__)
s = Serializer(app.config['SECRET_KEY'])
try:
data = s.loads(token)
except SignatureExpired:
return None # valid token, but expired
except BadSignature:
return None # invalid token
user = UserModel.query.get(data['id'])
return user
class FormativeAssessmentModel(database.Model):
__tablename__ = 'formativeAssessments'
fa_id = database.Column(database.Integer, primary_key=True, nullable=False)
topic_id = database.Column(database.Integer,
database.ForeignKey('topics.topic_id'))
is_unlocked = database.Column(database.Boolean, nullable=False)
max_credit = database.Column(database.Integer)
order_num = database.Column(database.Integer, nullable=False)
gained_credit = database.Column(database.Integer)
answer = database.Column(database.String)
pass_credit = database.Column(database.Integer)
instructions = database.Column(database.String)
title = database.Column(database.String(100), nullable=False)
path_to_attachment = database.Column(database.String)
deadline = database.Column(database.String)
reviewer_comment = database.Column(database.String)
is_marked = database.Column(database.Boolean)
topic = database.relationship('TopicModel')
def __init__(self, fa_id, topic_id, is_unlocked, order_num, max_credit,
gained_credit, answer, pass_credit, instructions, title,
path_to_attachment, deadline, reviewer_comment, is_marked):
self.fa_id = fa_id
self.topic_id = topic_id
self.is_unlocked = is_unlocked
self.max_credit = max_credit
self.order_num = order_num
self.gained_credit = gained_credit
self.answer = answer
self.pass_credit = pass_credit
self.instructions = instructions
self.title = title
self.path_to_attachment = path_to_attachment
self.deadline = deadline
self.reviewer_comment = reviewer_comment
self.is_marked = is_marked
def json(self):
return {
'fa_id': self.fa_id,
'topic_id': self.topic_id,
'is_unlocked': self.is_unlocked,
'max_credit': self.max_credit,
'order_num': self.order_num,
'gained_credit': self.gained_credit,
'answer': self.answer,
'pass_credit': self.pass_credit,
'instructions': self.instructions,
'title': self.title,
'path_to_attachment': self.path_to_attachment,
'deadline': self.deadline,
'reviewer_comment': self.reviewer_comment,
'is_marked': self.is_marked
}
def save_to_database(self):
database.session.add(self)
database.session.commit()
def delete_from_database(self, query, args):
database.session.delete(self)
database.session.commit()
@classmethod
def find_by_id(cls, fa_id):
return cls.query.filter_by(fa_id=fa_id).first()
@classmethod
def get_all(cls):
return cls.query.all()
@classmethod
def get_all_for_topic(cls, topic_id):
return cls.query.filter_by(topic_id=topic_id).all()
class ClassficationProblem(db.Model):
_tablename_ = "classifications"
id = db.Column(db.Integer, primary_key=True)
job_name = db.Column(db.String(255))
algorithm_name = db.Column(db.String(255))
train_accuracy = db.Column(db.Float)
test_accuracy = db.Column(db.Float)
train_f1 = db.Column(db.Float)
test_f1 = db.Column(db.Float)
project_id = db.Column(db.Integer,
db.ForeignKey("projects.id"),
nullable=False)
project = db.relationship("Project")
def __init__(self, job_name, algorithm_name, project_id):
self.job_name = job_name
self.algorithm_name = algorithm_name
self.project_id = project_id
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
def json(self):
return {
"id": self.id,
"job_name": self.job_name,
"algorithm_name": self.algorithm_name,
"train_accuracy": self.train_accuracy,
"test_accuracy": self.test_accuracy,
"train_f1": self.train_f1,
"test_f1": self.test_f1,
"project_id": self.project_id
}
@classmethod
def map_solution_to_solution_id(cls, solutions):
return [solution.id for solution in solutions]
@classmethod
def find_solution_with_id(cls, solution_id):
return cls.query.filter_by(id=solution_id).first()
@classmethod
def find_solutions_of_project(cls, project_id):
solutions = cls.query.filter_by(project_id=project_id).order_by(
ClassficationProblem.id.desc()).all()
return cls.map_solution_to_solution_id(solutions)
@classmethod
def find_best_solution_of_project(cls, project_id):
best_solution = cls.query.filter_by(project_id=project_id).filter(
cls.test_accuracy != None).order_by(
cls.test_accuracy.desc()).first()
return best_solution
def if_belongs_to(self, project_id):
return self.project_id == project_id
def analytics_filled(self):
return self.train_accuracy != None
def update_analytics(self, analytics):
self.train_accuracy = analytics["train:accuracy"]
self.test_accuracy = analytics["test:accuracy"]
self.train_f1 = analytics["train:f1"]
self.test_f1 = analytics["test:f1"]
self.save()
class PolicyModel(database.Model):
__tablename__ = 'policy_table'
policy_name = database.Column(database.String(80))
start_date = database.Column(database.String(80))
end_date = database.Column(database.String(80))
duration_in_years = database.Column(database.String(80))
company_name = database.Column(database.String(100))
initial_deposit = database.Column(database.Integer)
policy_type = database.Column(database.String(80))
user_type = database.Column(database.String(80))
terms_per_year = database.Column(database.Integer)
term_amount = database.Column(database.Integer)
interest = database.Column(database.Float)
maturity_amount = database.Column(database.Float)
policy_id = database.Column(database.String(120), primary_key=True)
def __init__(self, policy_name, start_date, end_date, duration_in_years, company_name, initial_deposit, policy_type,
user_type, terms_per_year, term_amount,
interest, maturity_amount, policy_id):
self.policy_name = policy_name
self.start_date = start_date
self.end_date = end_date
self.duration_in_years = duration_in_years
self.company_name = company_name
self.initial_deposit = initial_deposit
self.policy_type = policy_type
self.user_type = user_type
self.terms_per_year = terms_per_year
self.term_amount = term_amount
self.interest = interest
self.maturity_amount = maturity_amount
self.policy_id = policy_id
def json(self):
return {
'policy_name': self.policy_name,
'start_date': self.start_date,
'end_date': self.end_date,
'duration_in_years': self.duration_in_years,
'company_name': self.company_name,
'initial_deposit': self.initial_deposit,
'policy_type': self.policy_type,
'user_type': self.user_type,
'terms_per_year': self.terms_per_year,
'term_amount': self.term_amount,
'interest': self.interest,
'maturity_amount': self.maturity_amount,
'policy_id': self.policy_id
}
@classmethod
def find_by_policy_name(cls, policy_name):
return cls.query.filter_by(policy_name=policy_name).first()
@classmethod
def find_by_company_name(cls, company_name):
return cls.query.filter_by(company_name=company_name).first()
@classmethod
def find_by_policy_id(cls, policy_id):
return cls.query.filter_by(policy_id=policy_id).first()
@classmethod
def find_by_policy_type(cls, policy_type):
return cls.query.filter_by(policy_type=policy_type).get()
@classmethod
def find_by_years(cls, duration_in_years):
return cls.query.filter_by(duration_in_years=duration_in_years).get()
def save_to_database(self):
database.session.add(self)
database.session.commit()
def delete_to_database(self):
database.session.delete(self)
database.session.commit()