class Data(db.Model):
__tablename__ = "datas"
id = db.Column(db.Integer, primary_key=True)
smallInteger = db.Column(db.SmallInteger)
bigInteger = db.Column(db.BigInteger)
floatData = db.Column(db.Float(10))
numericData = db.Column(db.Numeric(10))
stringData = db.Column(db.String(250))
textData = db.Column(db.Text(200))
mediumText = db.Column(db.Text(65536))
longText = db.Column(db.Text(16777216))
largeBinary = db.Column(db.LargeBinary(300))
mediumBlob = db.Column(db.LargeBinary(65536))
longBlob = db.Column(db.LargeBinary(16777216))
pickle = db.Column(db.PickleType)
mediumPickle = db.Column(db.PickleType(65536))
longPickle = db.Column(db.PickleType(16777216))
unicodeData = db.Column(db.Unicode(10))
unicodeText = db.Column(db.UnicodeText)
booleanData = db.Column(db.Boolean(0))
dateData = db.Column(db.Date)
timeData = db.Column(db.Time)
dateTime = db.Column(db.DateTime)
interval = db.Column(db.Interval)
enumData = db.Column(db.Enum('father', 'mother'))
def __repr__(self):
return "Data {}".format(self.id)
class Solved(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(), unique=True, nullable=False)
topic = db.Column(db.String(), nullable=False)
solvedBy = db.Column(db.String())
link = db.Column(db.String())
sourceTitles = db.PickleType()
sourceLinks = db.PickleType()
class DetectData(db.Model):
id = db.Column(db.Integer, primary_key=True)
class_index = db.Column(db.Integer)
predicted_class = db.Column(db.String(120))
obj_score = db.Column(db.Float)
left = db.Column(db.Integer)
top = db.Column(db.Integer)
right = db.Column(db.Integer)
bottom = db.Column(db.Integer)
all_score = db.Column(db.PickleType())
multiple_obj = db.Column(db.PickleType())
image_id = db.Column(db.Integer, db.ForeignKey('image.id'))
class Method(db.Model):
id = db.Column(db.Integer, primary_key=True, unique=True)
name = db.Column(db.String(120), nullable=False)
method_pickle = db.Column(db.PickleType(pickler=dill))
user_id = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False)
minimize = db.Column(db.String(120), nullable=False)
# status of the method. Options: ["NOT STARTED", "ITERATING", "FINISHED"]
status = db.Column(db.String(120), nullable=True)
last_request = db.Column(db.PickleType(pickler=dill), nullable=True)
def __repr__(self):
return (
f"Method = id:{self.id}, name:{self.name}, user_id:{self.user_id}, minimize:{self.minimize}, "
f"status:{self.status}, last_request:{self.last_request}")
class Citizen(db.Model):
citizen_id = db.Column(db.Integer)
town = db.Column(db.String(257))
street = db.Column(db.String(257))
building = db.Column(db.String(257))
apartment = db.Column(db.Integer)
name = db.Column(db.String(257))
birth_date = db.Column(db.DateTime)
gender = db.Column(db.String(7))
relatives = db.Column(db.PickleType())
import_id = db.Column(db.Integer)
intern_id = db.Column(db.Integer, unique=True, primary_key=True)
def __init__(self, *args, **kwards):
super(Citizen, self).__init__(*args, **kwards)
def __repr__(self):
citizen = dict()
citizen["citizen_id"] = self.citizen_id
citizen["town"] = self.town
citizen["street"] = self.street
citizen["building"] = self.building
citizen["apartment"] = self.apartment
citizen["name"] = self.name
citizen["birth_date"] = self.birth_date.strftime('%d.%m.%Y')
citizen["gender"] = self.gender
citizen["relatives"] = self.relatives
return str(citizen)
class Session(db.Model, BaseEntity):
__tablename__ = 'session'
prints = ('id', 'subject')
uuid = db.Column(db.String(36))
wrk_get = db.Column(db.PickleType())
def __init__(self, wrk_get=None):
''' Initialize a session '''
self.uuid = str(uuid.uuid4())
self.wrk_get = wrk_get
def set_wrk_get(self, output):
self.wrk_get = output
db.session.add(self)
db.session.commit()
return (self)
@classmethod
def new_session(cls):
new_ses = cls()
db.session.add(new_ses)
db.session.commit()
return new_ses
@classmethod
def by_uuid(cls, uuid):
return cls.query.filter_by(uuid=uuid).first()
class CrossProduct(db.Model):
id = db.Column(db.Integer, primary_key=True)
vector1 = db.Column(db.PickleType(), nullable=False)
vector2 = db.Column(db.PickleType(), nullable=False)
result = db.Column(db.PickleType(), nullable=False)
created = db.Column(db.DateTime,
nullable=False,
default=db.func.current_timestamp())
def __init__(self, vector1, vector2, result):
self.vector1 = vector1
self.vector2 = vector2
self.result = result
def __repr__(self):
return "{} x {} = {}".format(self.vector1, self.vector2, self.result)
class cell_info(db.Model):
id = db.Column(db.Integer,primary_key=True)
name = db.Column(db.String(256))
shifts=db.Column(db.PickleType())
takt=db.Column(db.Integer)
def __repr__(self):
return '< Cell: '+self.name+' >'
class Order(db.Model):
id = db.Column(db.Integer, nullable=False, primary_key=True)
status = db.Column(db.String(20))
refId = db.Column(db.String(100))
date_created = db.Column(db.DateTime())
shippingAddress = db.Column(db.PickleType())
paid = db.Column(db.Boolean)
customer_id = db.Column(db.Integer, db.ForeignKey('user.id'))
class File(db.Model):
id = db.Column(db.Integer, primary_key=True)
question_list = db.Column(db.PickleType())
filename = db.Column(db.String(120))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
def __repr__(self):
return '<File {} {}>'.format(self.filename, self.question_list)
class RegisteredUser(db.Model):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(255))
last_name = db.Column(db.String(255))
email = db.Column(db.String(255), unique=True)
face_encoding = db.Column(db.PickleType())
balance = db.Column(db.Float())
def __str__(self):
return self.email
class Problem(db.Model):
id = db.Column(db.Integer, primary_key=True, unique=True)
name = db.Column(db.String(120), nullable=False)
problem_type = db.Column(db.String(120), nullable=False)
problem_pickle = db.Column(db.PickleType(pickler=dill))
user_id = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False)
minimize = db.Column(db.String(120), nullable=False)
def __repr__(self):
return f"Problem('{self.name}', '{self.problem_type}', '{self.owner}', '{self.minimize}'')"
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True, nullable=False)
email = db.Column(db.String(40), unique=True, nullable=False)
first_name = db.Column(db.String(40))
last_name = db.Column(db.String(40))
pwd_hash = db.Column(db.String(80), nullable=False)
position = db.Column(db.String(64))
about = db.Column(db.String(255))
topics = db.Column(db.PickleType())
class Space(db.Model):
id = db.Column(db.Integer, nullable=False, primary_key=True)
spaceId = db.Column(db.String(50))
store_name = db.Column(db.String(100), unique=True)
description = db.Column(db.Text)
telephone = db.Column(db.String(50))
email = db.Column(db.String(50), unique=True)
verified = db.Column(db.Boolean, default=False)
farm_address = db.Column(db.PickleType())
suspended = db.Column(db.Boolean, default=False)
logo = db.Column(db.String(50))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
space_cat_id = db.Column(db.Integer, db.ForeignKey('space_cat.id'))
products = db.relationship('Product', backref='space')
reviews = db.relationship('Review', backref='space')
class Product(db.Model):
id = db.Column(db.Integer, nullable=False, primary_key=True)
productID = db.Column(db.String(50))
name = db.Column(db.String(100))
description = db.Column(db.Text)
price = db.Column(db.Float)
images = db.Column(db.PickleType())
Instock = db.Column(db.Integer, default=0)
sale_unit = db.Column(db.String(50))
discount = db.Column(db.Float)
date_created = db.Column(db.DateTime())
reviews = db.relationship('Review', backref='product')
space_id = db.Column(db.Integer, db.ForeignKey('space.id'))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
product_cat_id = db.Column(db.Integer, db.ForeignKey('product_cat.id'))
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(120), index=True, unique=True)
nickName = db.Column(db.String(120), index=True, unique=True)
password = db.Column(db.String(120))
mods = db.Column(MutableList.as_mutable(db.PickleType()))
def hash_password(self, password):
self.password = pwd_context.encrypt(password)
def verify_password(self, password):
return pwd_context.verify(password, self.password)
def ch(self, nickName, email, password):
if (nickName): self.nickName = nickName
if (email): self.email = email
if password: self.hash_password(password)
class Employees(db.Model):
id = db.Column(
db.Integer,
primary_key=True,
autoincrement=True,
unique=True,
)
first_name = db.Column(db.String(30), index=True)
last_name = db.Column(db.String(30), index=True)
service_number = db.Column(db.String(30), index=True, unique=True)
department_id = db.Column(db.Integer, db.ForeignKey('department.id'))
department = db.relationship('Department', backref='employees')
work_shift = db.relationship('WorkShift', backref='employees')
encodings = db.Column(db.PickleType(), unique=True)
photo = db.Column(db.String(128))
def __str__(self):
return f'{self.first_name} {self.last_name}'
class SolutionArchive(db.Model):
id = db.Column(db.Integer, primary_key=True, unique=True)
problem_id = db.Column(db.Integer,
db.ForeignKey("problem.id"),
nullable=False)
solutions_dict_pickle = db.Column(db.PickleType(pickler=dill))
meta_data = db.Column(db.String(2000), nullable=False)
date = db.Column(db.DateTime, nullable=False)
@validates("solutions_dict_pickle")
def validate_dict(self, _, dict_):
if not isinstance(dict_, dict):
raise ValueError(
f"A dictionary must be supplied to SolutionArchive. Type of data suplied f{type(dict_)}"
)
if "variables" not in dict_ or "objectives" not in dict_:
raise ValueError(
"The dictrionary supplied to SolutionArchive must contain the keys 'variables' and 'objectives'"
)
return dict_
class Conversation(db.Model):
id = db.Column(db.Integer, primary_key=True)
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
context = db.Column(db.PickleType())
utterances = \
db.relationship('Utterance', backref='conversation', lazy='dynamic')
def add_speaker(self, speaker):
self.speakers.append(speaker)
def add_utterance(self, utterance):
utterance.conversation = self
utterance.timestamp = datetime.utcnow()
self.timestamp = utterance.timestamp
def get_first_user_utterance(self):
for u in self.utterances:
if u.speaker.email != '*****@*****.**':
return u
return None
def to_dict(self):
return_dict = {'id': self.id}
return_dict['timestamp'] = self.timestamp.isoformat() + 'Z'
return_dict['speakers'] = [s.to_dict() for s in self.speakers]
return_dict['utterances'] = [u.to_dict() for u in self.utterances]
return return_dict
def delete(self):
for u in self.utterances:
db.session.delete(u)
for s in self.speakers:
self.speakers.remove(s)
db.session.delete(self)
@staticmethod
def create():
conversation = Conversation()
conversation.context = []
db.session.add(conversation)
return conversation
class Device(db.Model):
__tablename__ = 'Device'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, unique=True)
text = db.Column(db.PickleType())
current = db.Column(db.Integer, default=0) # current page of device
def save(self):
db.session.add(self)
db.session.commit()
def update(self, text):
self.text = text
self.current = 0
db.session.commit()
def page(self): # get current page
data = str(self.text[self.current])
return data.replace(', ', '')[1:-1]
def next_page(self): # 다음 페이지
try:
self.text[self.current + 1]
self.current += 1
db.session.commit()
return True
except IndexError:
return False
def prev_page(self): # 이전 페이지
try:
self.text[self.current - 1]
self.current -= 1
db.session.commit()
return True
except IndexError:
return False
class User(db.Model):
__tablename__ = 'users'
ht_id = db.Column(db.Integer, primary_key=True, unique=True)
ht_user = db.Column(db.String(100), unique=True)
username = db.Column(db.String(100), unique=True)
password = db.Column(db.String(100))
access_key = db.Column(db.String(100))
access_secret = db.Column(db.String(100))
c_login = db.Column(db.Integer, default=1)
c_team = db.Column(db.Integer, default=0)
c_player = db.Column(db.Integer, default=0)
c_matches = db.Column(db.Integer, default=0)
c_training = db.Column(db.Integer, default=0)
c_update = db.Column(db.Integer, default=0)
last_login = db.Column(db.DateTime)
last_update = db.Column(db.DateTime)
last_usage = db.Column(db.DateTime)
created = db.Column(db.DateTime)
role = db.Column(db.String(100))
player_columns = db.Column(db.PickleType())
def __init__(self, ht_id, ht_user, username, password, access_key,
access_secret):
self.ht_id = ht_id
self.ht_user = ht_user
self.username = username
self.password = password
self.access_key = access_key
self.access_secret = access_secret
self.c_login = 1
self.c_team = 0
self.c_player = 0
self.c_matches = 0
self.c_training = 0
self.c_update = 0
self.last_login = time.strftime('%Y-%m-%d %H:%M:%S')
self.last_update = time.strftime('%Y-%m-%d %H:%M:%S')
self.last_usage = time.strftime('%Y-%m-%d %H:%M:%S')
self.created = time.strftime('%Y-%m-%d %H:%M:%S')
self.role = ""
self.player_columns = pickle.dumps([])
def __repr__(self):
return '<id {}>'.format(self.username)
def getRole(self):
return '{}'.format(self.role)
def setRole(self, newrole):
self.role = newrole
def claimUser(self, username, password, access_key, access_secret):
self.username = username
self.password = password
self.access_key = access_key
self.access_secret = access_secret
self.c_login += 1
self.last_login = time.strftime('%Y-%m-%d %H:%M:%S')
self.last_usage = time.strftime('%Y-%m-%d %H:%M:%S')
def login(self):
self.c_login += 1
self.last_login = time.strftime('%Y-%m-%d %H:%M:%S')
self.last_usage = time.strftime('%Y-%m-%d %H:%M:%S')
def player(self):
self.c_player += 1
self.last_usage = time.strftime('%Y-%m-%d %H:%M:%S')
def matches(self):
self.c_matches += 1
self.last_usage = time.strftime('%Y-%m-%d %H:%M:%S')
def team(self):
self.c_team = self.c_team + 1
self.last_usage = time.strftime('%Y-%m-%d %H:%M:%S')
def training(self):
self.c_training += 1
self.last_usage = time.strftime('%Y-%m-%d %H:%M:%S')
def updatedata(self):
self.c_update += 1
self.last_update = time.strftime('%Y-%m-%d %H:%M:%S')
self.last_usage = time.strftime('%Y-%m-%d %H:%M:%S')
def updateColumns(self, cols):
pcols = pickle.dumps(cols)
self.player_columns = pcols
def getColumns(self):
try:
pcols = pickle.loads(self.player_columns)
return pcols
except Exception:
return []
class Experiment(Base):
__tablename__ = 'experiments'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(128), nullable=False)
alias = db.Column(db.String(128), nullable=True)
notes = db.Column(db.Text(), nullable=True)
# authors = db.Column(db.String(128))
# tags = db.Column(db.String(128))
authors = db.relationship(
"Author",
secondary=experiment_author_table,
back_populates="experiments",
cascade="all,delete"
)
tags = db.relationship(
"Tag",
secondary=experiment_tags_table,
back_populates="experiments",
cascade="all,delete"
)
model = db.Column(db.PickleType(), nullable=True)
parameters = db.Column(db.PickleType(), nullable=True)
data_processed = db.Column(db.PickleType(), nullable=True)
dataset_alias = db.Column(db.String(256), nullable=True)
data_file_path = db.Column(db.String(256), nullable=False)
created_at = db.Column(db.DateTime(), default=datetime.datetime.utcnow)
updated_at = db.Column(db.DateTime(), default=datetime.datetime.utcnow)
queued_at = db.Column(db.DateTime(), nullable=True)
queued_end = db.Column(db.DateTime(), nullable=True)
queue = db.relationship("Queue", uselist=False, back_populates="experiment")
# def __init__(self, name=None, alias=None, notes=None, authors=None,
# tags=None, model=[], parameters=[], dataset_alias=None,
# data_file_path=None, queued_at=None):
# self.name = name
# self.alias = alias
# self.notes = notes
#
# self.authors.append(authors)
# self.tags.append(tags)
#
# self.model = model
# self.parameters = parameters
# self.dataset_alias = dataset_alias
# self.data_file_path = data_file_path
# self.queued_at = queued_at # datetime
def __init__(self, name=None, data_file_path=None, authors=None, tags=None, notes='default', alias='no-alias',
queued_at=None, queued_end=None, model=None):
self.name = name
self.data_file_path = data_file_path
self.notes = notes
self.alias = alias
self.queued_at = queued_at
self.queued_end = queued_end
self.model = model
if authors is not None and isinstance(authors[0], Author):
self.add_all_authors(authors)
elif authors is not None and isinstance(authors[0], str):
tmp_auth = [Author(x) for x in authors]
self.add_all_authors(tmp_auth)
if tags is not None and isinstance(tags[0], Tag):
self.add_all_tags(tags)
elif tags is not None and isinstance(tags[0], str):
tmp_tags = [Tag(x) for x in tags]
self.add_all_tags(tmp_tags)
def add_all_authors(self, author_list):
for a in author_list:
self.authors.append(a)
def add_all_tags(self, tags_list):
for t in tags_list:
self.tags.append(t)
def __repr__(self):
return '<Experiment %r(id:%d)>' % (self.name, self.id)
class Cart(db.Model):
id = db.Column(db.Integer, nullable=False, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
dateCreated = db.Column(db.DateTime())
products = db.Column(db.PickleType())
class PhotoFeatures(db.Model):
id = db.Column(db.Integer, primary_key=True)
person_name = db.Column(db.String(128), index=True)
vector = db.Column(db.PickleType())
model = db.Column(db.String(128))
filename = db.Column(db.String(300))
