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 } }