class Smartphone(db.Model):
__tablename__ = 'smartphones'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(128), nullable=False)
brand = db.Column(db.String(128), nullable=False)
price = db.Column(db.Float(4), nullable=False)
color = db.Column(db.String(128), nullable=False)
quantity = db.Column(db.Float(2), nullable=False)
propietario = db.Column(db.Integer, db.ForeignKey('personas.id'))
creation_date = db.Column(db.DateTime, default=func.now(), nullable=False)
modification_date = db.Column(db.DateTime,
default=func.now(),
nullable=True)
active = db.Column(db.Boolean(), default=True, nullable=False)
def __init__(self, **kwargs):
super(Smartphone, self).__init__(**kwargs)
# do custom initialization here
def to_json(self):
return {
'id': self.id,
'name': self.name,
'brand': self.brand,
'price': self.price,
'color': self.color,
'propietario': self.propietario,
'quantity': self.quantity,
'active': self.active
}
class Wakepark(db.Model):
__tablename__ = "wakeparks"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
created_date = db.Column(db.DateTime, default=func.now(), nullable=False)
active = db.Column(db.Boolean(), default=False, nullable=False)
name = db.Column(db.String(128), nullable=False)
description = db.Column(db.String(255), nullable=False)
lat = db.Column(db.Float(), nullable=True)
lng = db.Column(db.Float(), nullable=True)
instagram_handle = db.Column(db.String(128), nullable=True)
owner_id = db.Column(db.String(), default=True, nullable=False)
def __init__(
self,
name="",
lat="",
lng="",
description="",
instagram_handle="",
owner_id="google-oauth2|104755831296456998532",
):
self.name = name
self.description = description
self.lat = lat
self.lng = lng
self.instagram_handle = instagram_handle
self.owner_id = owner_id
def __repr__(self):
return (
f"<Wakepark id:{self.id},name:{self.name},owner:{self.owner_id}>")
def to_json(self):
ig_url = "https://www.instagram.com/"
return {
"id": self.id,
"name": self.name,
"owner_id": self.owner_id,
"location": {
"lat": self.lat,
"lng": self.lng
},
"description": self.description,
"social": {
"instagram": f"{ig_url}{self.instagram_handle}"
},
}
def to_dict(self):
return {
"id": self.id,
"name": self.name,
"lat": self.lat,
"lng": self.lng,
"description": self.description,
"instagram_handle": self.instagram_handle,
"owner_id": self.owner_id,
}
class Variant(db.Model):
"""The Variant model is a sparse dataset, composed of various attributes of a genomic variant"""
__tablename__ = 'variant'
id = db.Column(db.Integer, primary_key=True)
gene = db.Column(db.String(50))
nucleotide_change = db.Column(db.String())
protein_change = db.Column(db.String())
other_mappings = db.Column(db.String())
alias = db.Column(db.String(100))
transcripts = db.Column(db.String())
region = db.Column(db.String(50))
reported_classification = db.Column(db.String(100))
inferred_classification = db.Column(db.String(100))
source = db.Column(db.String(100))
last_evaluated = db.Column(db.Date())
last_updated = db.Column(db.Date())
url = db.Column(db.String(100))
submitter_comment = db.Column(db.String())
assembly = db.Column(db.String(15))
chr = db.Column(db.String(5))
genomic_start = db.Column(db.Float())
genomic_stop = db.Column(db.Float())
ref = db.Column(db.String(100))
alt = db.Column(db.String(100))
accession = db.Column(db.String(25))
reported_ref = db.Column(db.String(100))
reported_alt = db.Column(db.String(100))
def to_json(self, i):
"""Conversion of model object to json for returning from API endpoints"""
return {
'id': i + 1,
'gene': self.gene,
'nucleotide_change': self.nucleotide_change,
'protein_change': self.protein_change,
'other_mappings': self.other_mappings,
'alias': self.alias,
'transcripts': self.transcripts,
'region': self.region,
'reported_classification': self.reported_classification,
'inferred_classification': self.inferred_classification,
'source': self.source,
'last_evaluated': self.last_evaluated,
'last_updated': self.last_updated,
'url': self.url,
'submitter_comment': self.submitter_comment,
'assembly': self.assembly,
'chr': self.chr,
'genomic_start': self.genomic_start,
'genomic_stop': self.genomic_stop,
'ref': self.ref,
'alt': self.alt,
'accession': self.accession,
'reported_ref': self.reported_ref,
'reported_alt': self.reported_alt
}
class Station(db.Model):
__tablename__ = "stations"
# id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# here id will be the station_id, so no auto-incrememnt
id = db.Column(db.Integer(), primary_key=True, nullable=False)
station_name = db.Column(db.String(128), nullable=True)
available_docks = db.Column(db.Integer(), nullable=True)
total_docks = db.Column(db.Integer(), nullable=True)
latitude = db.Column(db.Float(), nullable=True)
longitude = db.Column(db.Float(), nullable=True)
status_value = db.Column(db.String(128), nullable=True)
status_key = db.Column(db.Integer(), nullable=True)
available_bikes = db.Column(db.Integer(), nullable=True)
st_address_1 = db.Column(db.String(128), nullable=True)
st_address_2 = db.Column(db.String(128), nullable=True)
city = db.Column(db.String(128), nullable=True)
postal_code = db.Column(db.String(128), nullable=True)
location = db.Column(db.String(128), nullable=True)
altitude = db.Column(db.String(128), nullable=True)
land_mark = db.Column(db.String(128), nullable=True)
test_station = db.Column(db.Boolean(), nullable=True)
last_communication_time = db.Column(db.String(128), nullable=True)
def __init__(self, id, station_name, available_docks, total_docks,
latitude, longitude, status_value, status_key,
available_bikes, st_address_1, st_address_2, city,
postal_code, location, altitude, land_mark, test_station,
last_communication_time):
self.id = id
self.station_name = station_name
self.available_docks = available_docks
self.total_docks = total_docks
self.latitude = latitude
self.longitude = longitude
self.status_value = status_value
self.status_key = status_key
self.available_bikes = available_bikes
self.st_address_1 = st_address_1
self.st_address_2 = st_address_2
self.city = city
self.postal_code = postal_code
self.location = location
self.altitude = altitude
self.land_mark = land_mark
self.test_station = test_station
self.last_communication_time = last_communication_time
def from_dict(self, data):
for field in [
'station_name', 'available_docks', 'total_docks', 'latitude',
'longitude', 'status_value', 'status_key', 'available_bikes',
'st_address_1', 'st_address_2', 'city', 'postal_code',
'location', 'altitude', 'land_mark', 'test_station',
'last_communication_time'
]:
if field in data:
setattr(self, field, data[field])
class Trade(db.Model):
__table_args__ = (UniqueConstraint('ticker_id',
'insider_id',
'transaction_type_id',
'last_date',
name='_insider__last_date'), )
id = db.Column(db.Integer, primary_key=True)
ticker_id = db.Column(db.Integer,
db.ForeignKey('ticker.id'),
nullable=False)
insider_id = db.Column(db.Integer,
db.ForeignKey('insider.id'),
nullable=False)
transaction_type_id = db.Column(db.Integer,
db.ForeignKey('transaction_type.id'),
nullable=False)
shares_traded = db.Column(db.Float(decimal_return_scale=3), nullable=False)
shares_held = db.Column(db.Float(decimal_return_scale=3), nullable=False)
last_price = db.Column(db.Float(decimal_return_scale=4), nullable=False)
last_date = db.Column(db.Date, nullable=False)
@classmethod
def get_or_create(cls,
ticker=None,
insider=None,
last_date=None,
transaction_type=None,
**kwargs):
instance = cls.query.filter_by(
ticker=ticker,
insider_id=insider.id,
last_date=last_date,
transaction_type=transaction_type).first()
if instance:
return instance, False
else:
instance = cls(ticker=ticker,
insider=insider,
last_date=last_date,
transaction_type=transaction_type,
**kwargs)
db.session.add(instance)
return instance, True
def update(self, commit=False, **kwargs):
for key, value in kwargs.items():
setattr(self, key, value)
if commit:
db.session.commit()
def __repr__(self):
return '<{} = {}, {}'.format(self.insider.name, self.last_price,
self.last_date)
class Rate(db.Model):
__table_args__ = (
UniqueConstraint('currency_id', 'date', name='_ticker__date'),
)
id = db.Column(db.Integer, primary_key=True)
currency_id = db.Column(db.Integer, db.ForeignKey('currency.id'), nullable=False)
date = db.Column(db.Date, nullable=False, server_default=func.current_date())
rate = db.Column(db.Float(decimal_return_scale=2), nullable=False)
volume = db.Column(db.Float(decimal_return_scale=2), nullable=False)
class Location(BaseMixin, db.Model):
description = db.Column(db.String(50), default='')
latitude = db.Column(db.Float(10, 8))
longitude = db.Column(db.Float(10, 8))
street = db.Column(db.String(50), nullable=False)
zipcode = db.Column(db.String(10), default='')
city = db.Column(db.String(50), nullable=False)
country = db.Column(db.String(50), nullable=False)
@property
def _descriptive(self):
return '{}, {} - {}'.format(self.street, self.city, self.country)
class StationHistory(db.Model):
__tablename__ = "station_histories"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
station_id = db.Column(db.Integer(),
db.ForeignKey("stations.id", ondelete="CASCADE"),
nullable=False)
station = db.relationship('Station',
backref=db.backref('station_histories',
passive_deletes=True))
station_name = db.Column(db.String(128), nullable=True)
available_docks = db.Column(db.Integer(), nullable=True)
total_docks = db.Column(db.Integer(), nullable=True)
latitude = db.Column(db.Float(), nullable=True)
longitude = db.Column(db.Float(), nullable=True)
status_value = db.Column(db.String(128), nullable=True)
status_key = db.Column(db.Integer(), nullable=True)
available_bikes = db.Column(db.Integer(), nullable=True)
st_address_1 = db.Column(db.String(128), nullable=True)
st_address_2 = db.Column(db.String(128), nullable=True)
city = db.Column(db.String(128), nullable=True)
postal_code = db.Column(db.String(128), nullable=True)
location = db.Column(db.String(128), nullable=True)
altitude = db.Column(db.String(128), nullable=True)
land_mark = db.Column(db.String(128), nullable=True)
test_station = db.Column(db.Boolean(), nullable=True)
last_communication_time = db.Column(db.String(128), nullable=True)
def __init__(self, station_id, station_name, available_docks, total_docks,
latitude, longitude, status_value, status_key,
available_bikes, st_address_1, st_address_2, city,
postal_code, location, altitude, land_mark, test_station,
last_communication_time):
self.station_id = station_id
self.station_name = station_name
self.available_docks = available_docks
self.total_docks = total_docks
self.latitude = latitude
self.longitude = longitude
self.status_value = status_value
self.status_key = status_key
self.available_bikes = available_bikes
self.st_address_1 = st_address_1
self.st_address_2 = st_address_2
self.city = city
self.postal_code = postal_code
self.location = location
self.altitude = altitude
self.land_mark = land_mark
self.test_station = test_station
self.last_communication_time = last_communication_time
class Persona(db.Model):
__tablename__ = 'personas'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(128), nullable=False)
lastname = db.Column(db.String(128), nullable=False)
age = db.Column(db.Float(2), nullable=False)
gender = db.Column(db.String(1), nullable=False)
smartphones = db.relationship('Smartphone')
creation_date = db.Column(db.DateTime, default=func.now(), nullable=False)
modification_date = db.Column(db.DateTime,
default=func.now(),
nullable=True)
active = db.Column(db.Boolean(), default=True, nullable=False)
def __init__(self, name, lastname, age, gender):
self.name = name
self.lastname = lastname
self.age = age
self.gender = gender
def to_json(self):
return {
'id': self.id,
'name': self.name,
'lastname': self.lastname,
'age': self.age,
'gender': self.gender,
'active': self.active
}
class Chest(db.Model):
__tablename__ = 'chests'
id = db.Column(db.BigInteger, primary_key=True)
title = db.Column(db.String(length=255), nullable=False)
description = db.Column(db.Text, nullable=False)
discount = db.Column(db.Float(), default=0)
is_active = db.Column(db.Boolean, nullable=False, default=False)
image = db.Column(db.Text, nullable=True)
avatars = db.relationship('Avatar',
secondary='chest_avatars',
back_populates='chests',
lazy='dynamic')
gem_id = db.Column(db.BigInteger, db.ForeignKey('gems.id'))
gem = db.relationship('Gem')
coin_id = db.Column(db.BigInteger, db.ForeignKey('coins.id'))
coin = db.relationship('Coin')
created = db.Column(db.TIMESTAMP,
default=datetime.datetime.now,
nullable=False)
updated = db.Column(db.TIMESTAMP,
default=datetime.datetime.now,
nullable=False,
onupdate=datetime.datetime.now)
def __str__(self):
return self.title
class Product(db.Model):
__tablename__ = 'products'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
nombre = db.Column(db.String(128), nullable=False)
cantidad = db.Column(db.Integer(), nullable=False)
precio = db.Column(db.Float(), nullable=False)
descripcion = db.Column(db.String(128), nullable=False)
categoria = db.Column(db.String(128), nullable=False)
active = db.Column(db.Boolean(), default=True, nullable=False)
def to_json(self):
return {
'id': self.id,
'nombre': self.nombre,
'cantidad': self.cantidad,
'precio': self.precio,
'descripcion': self.descripcion,
'categoria': self.categoria,
'active': self.active
}
def __init__(self, nombre, cantidad, precio, descripcion, categoria):
self.nombre = nombre
self.cantidad = cantidad
self.precio = precio
self.descripcion = descripcion
self.categoria = categoria
class Record(db.Model, AbstractModel):
product_id = db.Column(db.String(40),
db.ForeignKey("product.id"),
primary_key=True)
date = db.Column(db.DateTime(),
default=datetime.datetime.utcnow,
primary_key=True)
price = db.Column(db.Float(), nullable=False)
class Village(db.Model):
__tablename__ = 'villages'
id = db.Column(db.Integer, primary_key=True)
village = db.Column(db.String(255))
lattitude = db.Column(db.Float(precision=14))
longitude = db.Column(db.Float(precision=14))
subdistrict_id = db.Column(db.Integer, db.ForeignKey('subdistricts.id'))
# deliverables
projects = db.relationship("Project", backref='villages')
activities = db.relationship("Activity", backref='villages')
beneficiaries = db.relationship("Beneficiary", backref='villages')
remarks = db.relationship("Remark", backref='villages')
def __init__(self, village, lattitude, longitude, subdistrict_id):
self.village = village
self.lattitude = lattitude
self.longitude = longitude
self.subdistrict_id = subdistrict_id
class Feedback(db.Model):
__tablename__ = 'feedback'
id = db.Column(db.Integer, primary_key=True)
review = db.Column(db.String(), nullable=False)
summary = db.Column(db.String(), nullable=False)
positivity = db.Column(db.Float(), nullable=False)
def __init__(self, review, summary, positivity):
self.review = review
self.summary = summary
self.positivity = positivity
class User(db.Model, UserMixin):
id = db.Column(db.Integer(), primary_key=True)
email = db.Column(db.String(30), nullable=False, unique=True)
password = db.Column(db.String(),nullable=False)
matricola = db.Column(db.String(6), nullable=False, unique=True)
immatriculation_year = db.Column(db.Integer(), nullable=False)
num_of_ects = db.Column(db.Float(), nullable=False)
weighted_mean = db.Column(db.Float(), nullable=False)
score = db.Column(db.Float())
has_already_done_erasmus = db.Column(db.Boolean())
choice1 = db.Column(db.String())
choice2 = db.Column(db.String())
choice3 = db.Column(db.String())
registration_date = db.Column(db.DateTime(), nullable=False, default = datetime.now)
class NewCandidateInformation(db.Model):
matricola = db.Column(db.String(), primary_key=True)
name = db.Column(db.String())
surname = db.Column(db.String())
email = db.Column(db.String())
cdl = db.Column(db.String())
immatriculation_year = db.Column(db.Integer())
immatriculation_year_current = db.Column(db.Integer())
weighted_average = db.Column(db.Float())
num_of_ects = db.Column(db.Float())
score = db.Column(db.Float())
choice1 = db.Column(db.String())
duration1 = db.Column(db.Integer())
semester_c1 = db.Column(db.String())
choice2 = db.Column(db.String())
duration2 = db.Column(db.Integer())
semester_c2 = db.Column(db.String())
choice3 = db.Column(db.String())
duration3 = db.Column(db.Integer())
semester_c3 = db.Column(db.String())
mobility_type = db.Column(db.String())
previous_erasmus = db.Column(db.Boolean())
def get_score(self):
score = calc_score(
self.immatriculation_year_current,
self.num_of_ects,
self.weighted_average
)
print('calculated score:', score)
self.score = score
class ClientPosts(db.Model):
__tablename__ = "client_posts"
id = db.Column(db.Integer, primary_key=True)
topic = db.Column(db.String, nullable=False)
discipline = db.Column(db.String, nullable=False)
paper_type = db.Column(db.String, nullable=False)
ac_level = db.Column(db.String, nullable=False)
due_date = db.Column(db.TIMESTAMP, nullable=False)
total_pages = db.Column(db.Integer, nullable=False)
word_count = db.Column(db.String, nullable=False)
spacing = db.Column(db.String, nullable=False)
paper_format = db.Column(db.String, nullable=False)
sources = db.Column(db.Integer, nullable=False)
instructions = db.Column(db.String, nullable=False)
rev_instructions = db.Column(db.String, nullable=True)
order_status = db.Column(db.String, nullable=False)
payment_status = db.Column(db.String, nullable=False)
grand_total = db.Column(db.Float(precision=2), nullable=False)
author_id = db.Column(db.Integer, ForeignKey('users.id'))
files = relationship("OrderAttachments",
backref="client_posts",
uselist=False)
def __init__(self, \
topic, \
discipline, \
paper_type, \
ac_level, due_date, total_pages, word_count, spacing, paper_format, sources, \
instructions, \
order_status, \
payment_status, grand_total, author_id):
self.topic = topic
self.discipline = discipline
self.paper_type = paper_type
self.due_date = due_date
self.ac_level = ac_level
self.total_pages = total_pages
self.word_count = word_count
self.spacing = spacing
self.paper_format = paper_format
self.sources = sources
self.instructions = instructions
self.order_status = order_status
self.payment_status = payment_status
self.grand_total = grand_total
self.author_id = author_id
def __repr__(self):
return '<id - {}>'.format(self.id)
class Project(db.Model):
__tablename__ = 'projects'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(175), unique=True, nullable=False)
description = db.Column(db.Text)
#---------------------------
region = db.Column(db.Integer, db.ForeignKey('regions.id'))
district = db.Column(db.Integer, db.ForeignKey('districts.id'))
subdistrict = db.Column(db.Integer, db.ForeignKey('subdistricts.id'))
village = db.Column(db.Integer, db.ForeignKey('villages.id'))
#------------------------------------
baseline = db.Column(db.Text())
performance_indicator = db.Column(db.Text)
budget = db.Column(db.Float())
author = db.Column(db.Integer, db.ForeignKey('users.id'))
posted_date = db.Column(db.DateTime)
start_date = db.Column(db.DateTime)
est_completion = db.Column(db.DateTime)
mark_complete = db.Column(db.Boolean, default=False)
activities = db.relationship('Activity',
backref='projects',
cascade='all, delete-orphan',
lazy='dynamic')
remarks = db.relationship('Remark',
backref='projects',
cascade='all, delete-orphan',
lazy='dynamic')
beneficiary = db.Column(db.Integer, db.ForeignKey('beneficiaries.id'))
sector = db.Column(db.Integer, db.ForeignKey('sectors.id'))
media = db.relationship('Media',
secondary=projects_media,
backref='projects')
def __init__(self, id, title, description, baseline, performance_indicator,
budget, remark, remark_author, author, posted_date,
start_date, est_completion, mark_complete, sector):
self.id = id
self.title = title
self.description = description
self.baseline = baseline
self.performance_indicator = performance_indicator
self.budget = budget
self.author = author
self.posted_date = posted_date
self.start_date = start_date
self.est_completion = est_completion
self.mark_complete = mark_complete
self.sector = sector
class Log(db.Model):
__tablename__ = 'log'
log_id = db.Column(db.Integer(), primary_key=True)
device_id = db.Column(db.Integer(), unique=False)
book_id = db.Column(db.Integer(), unique=False)
datetime = db.Column(db.DateTime())
progress = db.Column(db.Float())
def __init__(self, device_id, book_id, datetime, progress):
self.device_id = device_id
self.book_id = book_id
self.datetime = datetime
self.progress = progress
def __repr__(self):
return '<User %r>' % self.datetime
class Person(db.Model):
"""Person class which initiates each row of the db with
a unique uuid using the standard library
"""
__tablename__ = 'people'
id = db.Column(db.String, primary_key=True)
survived = db.Column(db.Boolean(), default=False, nullable=False)
passengerClass = db.Column(db.Integer(), nullable=False)
name = db.Column(db.String(255), nullable=False)
sex = db.Column(db.String(255), nullable=False)
age = db.Column(db.Integer(), nullable=False)
siblingsOrSpousesAboard = db.Column(db.Integer(), nullable=False)
parentsOrChildrenAboard = db.Column(db.Integer(), nullable=False)
fare = db.Column(db.Float(), nullable=False)
def __init__(self, survived, passengerClass, name, sex, age,
siblingsOrSpousesAboard, parentsOrChildrenAboard, fare):
self.id = str(uuid4())
self.survived = survived
self.passengerClass = passengerClass
self.name = name
self.sex = sex
self.age = age
self.siblingsOrSpousesAboard = siblingsOrSpousesAboard
self.parentsOrChildrenAboard = parentsOrChildrenAboard
self.fare = fare
def to_json(self):
return {
'uuid': self.id,
'survived': self.survived,
'passengerClass': self.passengerClass,
'name': self.name,
'sex': self.sex,
'age': self.age,
'siblingsOrSpousesAboard': self.siblingsOrSpousesAboard,
'parentsOrChildrenAboard': self.parentsOrChildrenAboard,
'fare': self.fare
}
class Gem(db.Model):
__tablename__ = 'gems'
id = db.Column(db.BigInteger, primary_key=True)
title = db.Column(db.String(length=255), nullable=False)
description = db.Column(db.Text, nullable=False)
quantity = db.Column(db.Integer(), default=0, nullable=False)
price = db.Column(db.DECIMAL(precision=20, scale=4), default=0)
discount = db.Column(db.Float(), default=0)
type = db.Column(db.String(64), nullable=False, default=GemType.FORSALE)
created = db.Column(db.TIMESTAMP,
default=datetime.datetime.now,
nullable=False)
updated = db.Column(db.TIMESTAMP,
default=datetime.datetime.now,
nullable=False,
onupdate=datetime.datetime.now)
def __str__(self):
return self.title + " به تعداد " + str(
self.quantity) + " به قیمت " + str(
self.price) + " از نوع " + self.type
class Product(db.Model, AbstractModelWithId):
name = db.Column(db.Text(), nullable=False)
price = db.Column(db.Float(), nullable=False)
url = db.Column(db.Text(), nullable=False)
records = db.relationship('Record', uselist=True, lazy=True)
# followers = db.relationship('UserToProduct')
@classmethod
def filter(cls, filters):
query = AbstractModelWithId.filter(cls, filters)
if 'name' in filters:
query = query.filter_by(name=filters['name'])
elif 'url' in filters:
query = query.filter_by(url=filters['url'])
return query
def create(self):
super().create()
r = Record(product_id=self.id, price=self.price)
self.records.append(r)
db.session.flush()
def update(self):
super().update()
r = Record(product_id=self.id, price=self.price)
self.records.append(r)
db.session.flush()
@staticmethod
def extract_data(url):
response = requests.post(app.config.get('SCOUTER_ENDPOINT'),
data={
"url": url
}).json()
return response.get('name'), response.get('price')
class ItemModel(db.Model):
__tablename__ = 'items'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(81))
price = db.Column(db.Float(precision=2))
store_id = db.Column(db.Integer, db.ForeignKey('stores.id'))
cart_id = db.Column(db.Integer, db.ForeignKey('carts.id'))
likes = db.Column(db.Integer)
date_created = db.Column(db.String)
store = db.relationship('StoresModel')
def __init__(self, name, price, store_id):
self.name = name
self.price = price
self.store_id = store_id
self.date_created = str(datetime.datetime.now())
def json(self):
return {
'name': self.name,
'price': self.price,
'date_created': self.date_created,
'store_id': self.store_id
}
def save_to_db(self):
db.session.add(self)
db.session.commit()
def delete_from_db(self, _id):
item = ItemModel.query.get(_id)
db.session.delete(item)
db.session.commit()
def update_item_name(self, item_id, name):
# get item object from database
item = ItemModel.query.get(item_id)
# set the new item name
item.name = name
# save changes to databse
db.session.add(item)
db.session.commit()
# def update_item_name(self, item_id, price):
# # get item object from database
# item = ItemModel.query.get(item_id)
# # set the new item name
# item.price = price
# # save changes to databse
# db.session.add(item)
# db.session.commit()
@classmethod
def find_by_name(cls, name):
return cls.query.filter(ItemModel.name.contains(name))
# Model.query.filter(Model.columnName.contains('sub_string'))
@classmethod
def find_by_id(cls, _id):
return ItemModel.query.get(_id)
class PriceHistory(db.Model):
__table_args__ = (UniqueConstraint('ticker_id',
'date',
name='_ticker__date'), )
id = db.Column(db.Integer, primary_key=True)
ticker_id = db.Column(db.Integer,
db.ForeignKey('ticker.id'),
nullable=False)
date = db.Column(db.Date,
nullable=False,
server_default=func.current_date())
open = db.Column(db.Float(decimal_return_scale=2), nullable=False)
close = db.Column(db.Float(decimal_return_scale=2), nullable=False)
high = db.Column(db.Float(decimal_return_scale=2), nullable=False)
low = db.Column(db.Float(decimal_return_scale=2), nullable=False)
volume = db.Column(db.Integer, nullable=False)
@classmethod
def get_or_create(cls, ticker=None, date=None, **kwargs):
instance = cls.query.filter_by(ticker_id=ticker.id, date=date).first()
if instance:
return instance, False
else:
kwargs['volume'] = kwargs['volume'].replace(',', '')
instance = cls(ticker=ticker, date=date, **kwargs)
db.session.add(instance)
return instance, True
def update(self, commit=False, **kwargs):
for key, value in kwargs.items():
setattr(self, key, value)
if commit:
db.session.commit()
@classmethod
def get_analytics(cls, ticker_name, date_from, date_to):
PricesA = aliased(cls)
PricesB = aliased(cls)
result = db.session.query(
label('open', func.abs(PricesA.open - PricesB.open)),
label('close', func.abs(PricesA.close - PricesB.close)),
label('low', func.abs(PricesA.low - PricesB.low)),
label('high',
func.abs(PricesA.close - PricesB.high))).join(Ticker, ).join(
PricesB, and_(PricesB.ticker_id == Ticker.id)).filter(
Ticker.name == ticker_name,
PricesA.date == date_from, PricesB.date == date_to)
return result
@classmethod
def get_delta(cls, ticker_name, type_price, value):
sql = text(
DELTA_SELECT.format(ticker_name=ticker_name,
type_price=type_price,
value_delta=value))
result = db.engine.execute(sql)
return result.fetchall()
def __repr__(self):
return '<{} = {}, {}'.format(self.ticker.name, self.volume, self.date)
class Run(db.Model):
__tablename__ = "runs"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
run_name = db.Column(db.String(128), nullable=True)
cl = db.Column(db.Float(), nullable=False)
re = db.Column(db.Float(), nullable=False, default=1e6)
ma = db.Column(db.Float(), nullable=False, default=0.0)
n_c = db.Column(db.Integer(), nullable=False)
n_t = db.Column(db.Integer(), nullable=False)
gen = db.Column(db.Integer(), nullable=False, default=100)
tolx = db.Column(db.Float(), nullable=False)
tolf = db.Column(db.Float(), nullable=False)
fix_te = db.Column(db.Boolean(), nullable=False, default=True)
t_te_min = db.Column(db.Float(), nullable=True, default=0.0)
t_c_min = db.Column(db.Float(), nullable=True, default=0.01)
r_le_min = db.Column(db.Float(), nullable=True, default=0.01)
A_cs_min = db.Column(db.Float(), nullable=True, default=None)
A_bins_min = db.Column(db.Float(), nullable=True, default=None)
Cm_max = db.Column(db.Float(), nullable=True, default=None)
strategy = db.Column(db.String(),
default="rand-to-best/1/exp/random",
nullable=False)
f = db.Column(db.Float(), default=None, nullable=True)
cr = db.Column(db.Float(), default=None, nullable=True)
adaptivity = db.Column(db.Integer(), default=2, nullable=False)
n_proc = db.Column(db.Integer(), nullable=False, default=28)
report = db.Column(db.Boolean(), nullable=False, default=False)
status = db.Column(db.Integer(), nullable=False, default=0)
progress = db.Column(db.JSON, nullable=False, default=None)
def __init__(
self,
cl,
re,
ma,
n_c,
n_t,
gen=100,
tolx=1e-8,
tolf=1e-8,
fix_te=True,
t_te_min=0.0,
t_c_min=0.01,
r_le_min=0.01,
A_cs_min=None,
A_bins_min=None,
Cm_max=None,
cm_ref=None,
strategy="rand-to-best/1/exp/random",
f=None,
cr=None,
adaptivity=2,
n_proc=28,
run_name=None,
report=False,
progress=None,
):
self.run_name = run_name
self.cl = cl
self.re = re
self.ma = ma
self.n_c = n_c
self.n_t = n_t
self.gen = gen
self.tolx = tolx
self.tolf = tolf
self.fix_te = fix_te
self.t_te_min = t_te_min
self.t_c_min = t_c_min
self.r_le_min = r_le_min
self.A_cs_min = A_cs_min
self.A_bins_min = A_bins_min
self.Cm_max = Cm_max
self.cm_ref = cm_ref
self.strategy = strategy
self.f = f
self.cr = cr
self.adaptivity = adaptivity
self.n_proc = n_proc
self.report = report
self.progress = progress
def __iter__(self):
values = vars(self)
for attr in self.__mapper__.columns.keys():
if attr in values:
yield attr, values[attr]
def to_json(self):
return dict([(key, value) for key, value in self.__iter__()])
class TeamModel(db.Model):
__tablename__ = 'championship'
id = db.Column(db.Integer, primary_key=True)
team_name = db.Column(db.String(80))
spi = db.Column(db.Float(precision=1))
off = db.Column(db.Float(precision=1))
defi = db.Column(db.Float(precision=1))
goal_dif = db.Column(db.Integer)
pts = db.Column(db.Integer)
relegated = db.Column(db.Integer)
make_from_playoffs = db.Column(db.Integer)
promoted = db.Column(db.Integer)
win_championship = db.Column(db.Integer)
def __init__(self,
team_name,
spi=None,
off=None,
defi=None,
goal_dif=None,
pts=None,
relegated=None,
make_from_playoffs=None,
promoted=None,
win_championship=None):
self.team_name = team_name
self.spi = spi
self.off = off
self.defi = defi
self.goal_dif = goal_dif
self.pts = pts
self.relegated = relegated
self.make_from_playoffs = make_from_playoffs
self.promoted = promoted
self.win_championship = win_championship
def json(self):
return {
'id': self.id,
'team_name': self.team_name,
'spi': self.spi,
'off': self.off,
'defi': self.defi,
'goal_dif': self.goal_dif,
'pts': self.pts,
'relegated': self.relegated,
'make_from_playoffs': self.make_from_playoffs,
'promoted': self.promoted,
'win_championship': self.win_championship
}
@classmethod
def find_all(cls):
return cls.query.all()
@classmethod
def find_by_name(cls, team_name):
return cls.query.filter_by(team_name=team_name).first()
def save_to_db(self):
db.session.add(self)
db.session.commit()
class DroneTelemetry(db.Model):
__tablename__ = "drone_telemetry"
# Column's definition
id = db.Column(db.Integer, primary_key=True)
airspeed = db.Column(db.Float(precision=2))
alt = db.Column(db.Float(precision=2))
battery_perc = db.Column(db.Float(precision=2))
dist_home = db.Column(db.Float(precision=2))
compass1_x = db.Column(db.Integer)
compass1_y = db.Column(db.Integer)
compass1_z = db.Column(db.Integer)
compass2_x = db.Column(db.Integer)
compass2_y = db.Column(db.Integer)
compass2_z = db.Column(db.Integer)
compass_variance = db.Column(db.Float(precision=2))
current = db.Column(db.Float(precision=2))
fix_type = db.Column(db.Integer)
flight_mode = db.Column(db.String(300))
gps_sats = db.Column(db.Integer)
gps_fix = db.Column(db.Integer)
gps2_sats = db.Column(db.Integer)
gps2_fix = db.Column(db.Integer)
irlock_x = db.Column(db.Float(precision=2))
irlock_y = db.Column(db.Float(precision=2))
irlock_status = db.Column(db.Boolean)
lat = db.Column(db.Float(precision=8))
lon = db.Column(db.Float(precision=8))
num_gps = db.Column(db.Integer)
pos_horiz_variance = db.Column(db.Float(precision=2))
pos_vert_variance = db.Column(db.Float(precision=2))
rcout1 = db.Column(db.Integer)
rcout2 = db.Column(db.Integer)
rcout3 = db.Column(db.Integer)
rcout4 = db.Column(db.Integer)
rcout5 = db.Column(db.Integer)
rcout6 = db.Column(db.Integer)
rcout7 = db.Column(db.Integer)
rcout8 = db.Column(db.Integer)
sonar_dist = db.Column(db.Float(precision=2))
throttle = db.Column(db.Integer)
vibrations_x = db.Column(db.Float(precision=10))
vibrations_y = db.Column(db.Float(precision=10))
vibrations_z = db.Column(db.Float(precision=10))
voltage = db.Column(db.Float(precision=2))
velocity_variance = db.Column(db.Float(precision=2))
terrain_alt_variance = db.Column(db.Float(precision=2))
waypoint = db.Column(db.Integer)
yaw = db.Column(db.Integer)
timestamp = db.Column(db.DateTime)
qhawax_id = db.Column(db.Integer, db.ForeignKey("qhawax.id"))
class YoutubeVideoMeta(db.Model):
__tablename__ = "meta"
id = db.Column(db.VARCHAR(12),
db.ForeignKey("video.id"),
primary_key=True,
unique=True)
snippet_publishedAt = db.Column(db.DateTime(timezone=True))
snippet_channel_id = db.Column(db.VARCHAR(50))
snippet_channel_title = db.Column(db.VARCHAR(100))
snippet_title = db.Column(db.Text())
snippet_description = db.Column(db.VARCHAR(5000))
snippet_category_id = db.Column(db.Integer, db.ForeignKey("categories.id"))
snippet_tags = db.Column(db.Text())
snippet_liveBroadcastContent = db.Column(db.VARCHAR(10))
statistics_viewCount = db.Column(db.Integer)
statistics_likeCount = db.Column(db.Integer)
statistics_dislikeCount = db.Column(db.Integer)
#deprecated since august 28, 2015. always set to zero
statistics_favoriteCount = db.Column(db.Integer)
statistics_commentCount = db.Column(db.Integer)
status_uploadStatus = db.Column(db.VARCHAR(20))
status_privacyStatus = db.Column(db.VARCHAR(20))
status_license = db.Column(db.VARCHAR(20))
status_embeddable = db.Column(db.BOOLEAN)
status_publicStatsViewable = db.Column(db.BOOLEAN)
#the duration of the video is given as a ISO 8601 time interval
contentDetails_duration = db.Column(db.VARCHAR(20))
#the ISO 8601 time interval calculated into seconds
contentDetails_durationAsSeconds = db.Column(db.Integer)
contentDetails_dimension = db.Column(db.VARCHAR(2))
contentDetails_definition = db.Column(db.VARCHAR(2))
#based on google documentation this field is a string, containing 'true' or 'false', if you want to use boolean instead, you have to manually convert the string into bool
contentDetails_caption = db.Column(db.String(4))
contentDetails_licensedContent = db.Column(db.BOOLEAN)
recordingDetails_location_latitude = db.Column(db.Float(precision='10,6'))
recordingDetails_location_longitude = db.Column(db.Float(precision='10,6'))
recordingDetails_location_altitude = db.Column(db.Float(precision='10,6'))
recordingDetails_recordingDate = db.Column(db.DateTime(timezone=True))
def getCategoryId(self):
return self.snippet_category_id
def as_dict(self):
return {
'snippet': {
'publishedAt':
self.snippet_publishedAt,
'channelId':
self.snippet_channel_id,
'channelTitle':
self.snippet_channel_title,
'title':
self.snippet_title,
'description':
self.snippet_description,
'categoryId':
self.snippet_category_id,
'tags':
json.loads(self.snippet_tags)
if self.snippet_tags != '' else None
}
}
