class FeatureParticipation(ModelBase): __tablename__ = 'feature_participation' user_id = db.Column(db.Integer(), db.ForeignKey('app_user.id', onupdate='CASCADE', ondelete='CASCADE'), primary_key=True) feature_id = db.Column(db.Integer(), db.ForeignKey('feature.id', onupdate='CASCADE', ondelete='CASCADE'), primary_key=True) def __init__(self, user_id: int, feature_id: int): if not isinstance(user_id, int): raise expected('user_id', user_id, int) if not isinstance(feature_id, int): raise expected('feature_id', feature_id, int) self.user_id = user_id self.feature_id = feature_id @staticmethod def create(user: AppUser, feature: Feature) -> 'Optional[FeatureParticipation]': participation = FeatureParticipation(user.id, feature.id) db.session.add(participation) return participation @staticmethod def get_for_user(user: AppUser, feature: Feature) -> 'Optional[FeatureParticipation]': return FeatureParticipation.query.filter_by(user_id=user.id, feature_id=feature.id).first() def __hash__(self): return hash((self.user_id, self.feature_id))
class CITypeRelation(db.Model): __tablename__ = "ci_type_relations" ctr_id = db.Column(db.Integer, primary_key=True, autoincrement=True) parent_id = db.Column(db.Integer, db.ForeignKey("ci_types.type_id"), primary_key=True) parent = db.relationship( "CIType", primaryjoin="CIType.type_id==CITypeRelation.parent_id") child_id = db.Column(db.Integer, db.ForeignKey("ci_types.type_id"), primary_key=True) child = db.relationship( "CIType", primaryjoin="CIType.type_id==CITypeRelation.child_id") relation_type = db.Column(db.String(7), db.Enum("contain", "connect", "deploy", "install", name="relation_type"), default="contain") __table_args__ = (db.UniqueConstraint("parent_id", "child_id", name="parent_child_uniq"), )
class Token(db.Model): id = db.Column(db.Integer, primary_key=True) client_id = db.Column( db.String(40), db.ForeignKey('client.client_id'), nullable=False, ) client = db.relationship('Client') user_id = db.Column(db.Integer, db.ForeignKey('user.id')) user = db.relationship('User') # currently only bearer is supported token_type = db.Column(db.String(40)) access_token = db.Column(db.String(255), unique=True) refresh_token = db.Column(db.String(255), unique=True) expires = db.Column(db.DateTime) _scopes = db.Column(db.Text) @property def scopes(self): if self._scopes: return self._scopes.split() return []
class Sentence(db.Model): __tablename__ = 'sentence' id = db.Column(db.Integer(), primary_key=True) text = db.Column(db.String()) sentiment = db.Column(db.Float()) status = db.Column(db.String()) #CONTEXT, SENTIMENT, PRED, DONE date = db.Column(db.String()) time = db.Column(db.String()) article_id = db.Column(db.Integer(), db.ForeignKey('article.id')) context = db.Column(db.String(), db.ForeignKey("company.stock_code")) def __init__(self, text, article_id, date, time): #self.id = id self.text = text self.article_id = article_id self.status = "CONTEXT" self.date = self.time = datetime.strptime(date, '%m/%d/%Y') self.time = datetime.strptime(time, '%H:%M:%S') def __repr__(self): return '<id {}>'.format(self.id) def serialize(self): return { 'id': self.id, 'text': self.text, 'sentiment': self.sentiment, 'status': self.status, 'article_id': self.article_id, 'date': self.date.strftime("%m/%d/%Y"), 'time': self.time.strftime("%H:%M:%S"), 'context': self.context }
class Reservation(db.Model): __tablename__ = 'reservation' id = db.Column(db.Integer, primary_key=True) # generoitu user_id = db.Column(db.Integer(), db.ForeignKey("user.id")) # varauksen tekijän id workspace_id = db.Column(db.Integer(), db.ForeignKey("workspace.id")) # työtilan id # default lähinnä testinä, todellisuudessa ei tietty voi varata tilaa ilman aikaa start_time = db.Column(db.DateTime(), nullable=False, server_default=db.func.now()) # aloitusaika # defaultend = db.func.now() + timedelta(hours=1) # server_default= defaultend # ilmesesti sqalkemian timestamp-hässäkkä ei ole yhteensopiva pythonin oman timestamp-hässäkän kanssa end_time = db.Column(db.DateTime(), nullable=False, server_default=db.func.now()) # lopetusaika created_at = db.Column(db.DateTime(), nullable=False, server_default=db.func.now()) updated_at = db.Column(db.DateTime(), nullable=False, server_default=db.func.now(), onupdate=db.func.now()) @classmethod def get_by_id(cls, id): return cls.query.filter_by(username=id).first() @classmethod def get_by_user_id(cls, user_id): return cls.query.filter_by(email=user_id).first() def save(self): db.session.add(self) db.session.commit()
class Grant(db.Model): id = db.Column(db.Integer, primary_key=True) user_id = db.Column(db.Integer, db.ForeignKey('user.id', ondelete='CASCADE')) user = db.relationship('User') client_id = db.Column( db.String(40), db.ForeignKey('client.client_id'), nullable=False, ) client = db.relationship('Client') code = db.Column(db.String(255), index=True, nullable=False) redirect_uri = db.Column(db.String(255)) expires = db.Column(db.DateTime) _scopes = db.Column(db.Text) def delete(self): db.session.delete(self) db.session.commit() return self @property def scopes(self): if self._scopes: return self._scopes.split() return []
class Votes(db.Model): __tablename__ = "m_votes" id = db.Column(db.Integer(), primary_key=True, unique=True, nullable=False, index=True, autoincrement=True) author_id = db.Column(db.Integer(), db.ForeignKey("m_user.id"), nullable=False) topic_id = db.Column(db.Integer(), db.ForeignKey("t_topics.id"), nullable=False) answer_id = db.Column(db.Integer(), db.ForeignKey("m_answer.id"), nullable=False) up_votes = db.Column(db.Integer(), nullable=True, default=0) down_votes = db.Column(db.Integer(), nullable=True, default=0) @classmethod def check_author_if_voted(cls, author_id, topic_id, answer_id): return cls.query.filter_by(author_id=author_id).filter_by( topic_id=topic_id).filter_by(answer_id=answer_id).first() def save(self): db.session.add(self) db.session.commit() def delete(self): db.session.delete(self) db.session.commit()
class UserDishWeight(db.Model): __tablename__ = 'user_dish_weight' user_id = db.Column(db.Integer, db.ForeignKey('user.id'), primary_key=True) dish_id = db.Column(db.Integer, db.ForeignKey('dish.id'), primary_key=True) user = db.relationship('User') dish = db.relationship('Dish') weight = db.Column(db.Float, default=1.0)
class PhoneAlarm(BaseModel): __tablename__ = "phone_alarm" phone_id = db.Column(db.CHAR(36), db.ForeignKey("phone.pid"), primary_key=True) alarm_id = db.Column(db.Integer, db.ForeignKey("alarm.aid"), primary_key=True) timestamp = db.Column(db.DateTime(), nullable=True) status = db.Column(db.BOOLEAN, nullable=True) alarm = relationship("Alarm", back_populates="phones") phone = relationship("Phone", back_populates="alarms") def serialize(self): return { "pid": self.phone_id, "aid": self.alarm_id, "status": self.status, "timestamp": re.sub('[-:+]', '', self.timestamp.isoformat()) + 'Z' if self.timestamp is not None else None }
class LikesOfComment(db.Model): """[Class for the likes on the coments] RelationShips: 1:1 Wiht User 1:M With Comments Args: db.Model ([sqlAlchemy]): [sqlALCHEMY] """ __tablename__ = "likes_of_comment" __table_args__ = {'extend_existing': True} id = db.Column(db.Integer, primary_key=True) created_date = db.Column(db.DateTime, default=datetime.datetime.utcnow) user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False) comment_id = db.Column(db.Integer, db.ForeignKey('comments.id'), nullable=False) def convert_to_json(self): return { "id": self.id, "user_id": self.user_id, "comment_id": self.comment_id, "created_date": self.created_date } def __repr__(self): return "<Likes %r,%r" % (self.id, self.created_date)
class Likes(db.Model): """[Likes Models] RelationsShips: M:1 With User M:1 With Beach Args: db.Model ([sqlAlchemy]): [sqlAlchemy instance] """ __tablename__ = "likes" __table_args__ = {'extend_existing': True} id = db.Column(db.Integer, primary_key=True) created_date = db.Column(db.DateTime, default=datetime.datetime.utcnow) user_id = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False) beach_id = db.Column(db.Integer, db.ForeignKey("beach.id"), nullable=False) def convert_to_json(self): return { "id": self.id, "user_id": self.user_id, "created_date": self.created_date, "beach_id": self.beach_id } def __repr__(self): return "<Likes %r,%r>" % (self.id, self.created_date)
class Reservation(db.Model): __tablename__ = 'reservation' id = db.Column(db.Integer, primary_key=True) client_id = db.Column(db.Integer(), db.ForeignKey("client.id")) workspace_id = db.Column(db.Integer(), db.ForeignKey("workspace.id")) created_at = db.Column(db.DateTime(), nullable=False, server_default=db.func.now()) updated_at = db.Column(db.DateTime(), nullable=False, server_default=db.func.now(), onupdate=db.func.now()) @classmethod def get_all_by_client(cls, client_id): return cls.query.filter_by(client_id=client_id).all() @classmethod def get_by_id(cls, reservation_id): return cls.query.filter_by(id=reservation_id).first() @classmethod def get_by_client(cls, client_id): return cls.query.filter_by(client_id=client_id).first() @classmethod def get_by_workspace(cls, workspace_id): return cls.query.filter_by(workspace_id=workspace_id).first() def save(self): db.session.add(self) db.session.commit() def delete(self): db.session.delete(self) db.session.commit()
class CIRelation(db.Model): __tablename__ = "ci_relations" cr_id = db.Column(db.Integer, primary_key=True, autoincrement=True) first_ci_id = db.Column(db.Integer, db.ForeignKey("cis.ci_id"), primary_key=True) second_ci_id = db.Column(db.Integer, db.ForeignKey("cis.ci_id"), primary_key=True) first_ci = db.relationship("CI", primaryjoin="CI.ci_id==CIRelation.first_ci_id") second_ci = db.relationship( "CI", primaryjoin="CI.ci_id==CIRelation.second_ci_id") relation_type = db.Column(db.String(8), db.Enum("connect", "deploy", "install", "contain", name="relation_type"), nullable=False) more = db.Column(db.Integer, db.ForeignKey("cis.ci_id")) __table_args__ = (db.UniqueConstraint("first_ci_id", "second_ci_id", name="first_second_uniq"), )
class Invoice(db.Model): id = db.Column(db.Integer, primary_key=True) ref = db.Column(db.String(40), nullable=False, index=True) company_id = db.Column(db.Integer, db.ForeignKey('company.id', ondelete='CASCADE'), nullable=False) staff = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False) datetime = db.Column(db.DateTime, default=datetime.utcnow, nullable=False, index=True) customer_id = db.Column(db.Integer, db.ForeignKey('customer.id', ondelete='CASCADE'), nullable=False) delivery_charge = db.Column(db.Integer, nullable=False, default=0) remarks = db.Column(db.String(100)) discount_id = db.Column(db.Integer, db.ForeignKey('discount.id', ondelete=None)) payment = db.relationship('Payment', backref='invoice', uselist=False, lazy=True) item = db.relationship('InvoicedItem', backref='invoice', lazy=True) shipment = db.relationship('Shipment', backref='invoice', lazy=True, uselist=False) discount = db.relationship('Discount')
class user_account(UserMixin, db.Model): __tablename__ = 'user_account' id = db.Column(db.Integer, primary_key=True) user_id = db.Column(db.Integer, db.ForeignKey('user_personal.id'), nullable=False) role_id = db.Column(db.Integer, db.ForeignKey('user_role.id'), nullable=False) username = db.Column(db.String(30), nullable=False) password = db.Column(db.String(30), nullable=False) date_created = db.Column(db.DateTime, nullable=False) last_active = db.Column(db.DateTime, nullable=False) status = db.Column(db.String(1), nullable=False) user_account_id = db.relationship('blood_center', backref='user_account', lazy=True) user_request_id = db.relationship('blood_request', backref='user_account', lazy=True) user_participate_id = db.relationship('event_participate', backref='user_account', lazy=True) def __repr__(self, active=True): return '<user_account {}>'.format(self.username)
class Show(db.Model): __tablename__ = 'Show' id = db.Column(db.Integer, primary_key=True) start_time = db.Column(db.DateTime(), nullable=False) venue_id = db.Column(db.Integer, db.ForeignKey('Venue.id'), nullable=False) artist_id = db.Column(db.Integer, db.ForeignKey('Artist.id'), nullable=False)
class LibraryEntry(db.Model): __tablename__ = 'libraries' __table_args__ = {'extend_existing': True} id = db.Column(db.Integer, primary_key=True) game_id = db.Column(db.Integer, db.ForeignKey('games.id'), nullable=False) release_id = db.Column(db.Integer, db.ForeignKey('releases.id'), nullable=False) user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False) play_status_id = db.Column(db.Integer, db.ForeignKey('play_statuses.id'), nullable=False) score = db.Column(db.Integer) own = db.Column(db.Integer, nullable=False, default=1) digital = db.Column(db.Integer, nullable=False, default=0) hours = db.Column(db.Integer) notes = db.Column(db.String) created_at = db.Column(db.DateTime, nullable=True, default=datetime.now) updated_at = db.Column(db.DateTime, nullable=True, default=datetime.now, onupdate=datetime.now) game = db.relationship('Game') release = db.relationship('Release') user = db.relationship('User') play_status = db.relationship('PlayStatus') def __repr__(self): return '<LibraryEntry %r>' % self.id
class Application(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(50), nullable=False) last_name = db.Column(db.String(100), nullable=False) email = db.Column(db.String(100), nullable=False) tel = db.Column(db.String(19), nullable=False) car_brand_id = db.Column(db.Integer, db.ForeignKey('car_brand.id'), nullable=False) car_brand = db.relationship('CarBrand') car_model_id = db.Column(db.Integer, db.ForeignKey('car_model.id'), nullable=False) car_model = db.relationship('CarModel') unique_track_number = db.Column(db.Integer, default=_generate_unique_track_number) date = db.Column(db.DateTime, default=datetime.now()) status_id = db.Column(db.Integer, db.ForeignKey('status.id'), default=1) status = db.relationship('Status') def __repr__(self): return f'<Application id: {self.id}, Name: {self.name}, Last name: {self.last_name}, E-mail: {self.email},' \ f' Telephone number: {self.tel}, Car brand id: {self.car_brand_id}, Car model id: {self.car_model_id}, ' \ f'Date: {self.date} ' def serialize(self): result = { 'track_number': self.unique_track_number, 'car_brand': self.car_brand.name, 'car_model': self.car_model.name, 'price': self.car_model.price, 'date': self.date, 'status': self.status.name } return result
class Round(db.Model): id = db.Column(db.Integer, primary_key=True) poem_id = db.Column(db.Integer, db.ForeignKey('poem.id'), nullable=False) number = db.Column(db.Integer) current = db.Column(db.Boolean, default=True) length = db.Column( db.Integer) # if corpus is timed, then length is prescriptive first_line_id = db.Column(db.Integer, db.ForeignKey("line.id")) second_line_id = db.Column(db.Integer, db.ForeignKey("line.id")) first_line = db.relationship( 'Line', foreign_keys=[first_line_id], backref='roundAppearingAsPrompt', lazy=True) #maybe alias as exposed_line for number > 0 second_line = db.relationship('Line', foreign_keys=[second_line_id], backref='roundWrittenIn', lazy=True) start_time = db.Column(db.DateTime, server_default=db.func.now(), nullable=False) completed_time = db.Column(db.DateTime, nullable=True) def __init__(self, number): self.number = number def complete(self): self.current = False
class Recommendation(db.Model): __tablename__ = 'recommendations' __table_args__ = {'extend_existing': True} id = db.Column(db.Integer, primary_key=True) content = db.Column(db.Text, nullable=False) user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False) game_id = db.Column(db.Integer, db.ForeignKey('games.id'), nullable=False) release_id = db.Column(db.Integer, db.ForeignKey('releases.id'), nullable=False) second_game_id = db.Column(db.Integer, db.ForeignKey('games.id'), nullable=False) second_release_id = db.Column(db.Integer, db.ForeignKey('releases.id'), nullable=False) created_at = db.Column(db.DateTime, nullable=True, default=datetime.now) updated_at = db.Column(db.DateTime, nullable=True, default=datetime.now, onupdate=datetime.now) user = db.relationship('User') game = db.relationship('Game', foreign_keys=[game_id]) release = db.relationship('Release', foreign_keys=[release_id]) recommended_game = db.relationship('Game', foreign_keys=[second_game_id]) recommended_release = db.relationship('Release', foreign_keys=[second_release_id]) def __repr__(self): return '<Recommendation %r>' % self.id
class Colonne(db.Model): numCol = db.Column(db.Integer, primary_key=True) graphId = db.Column(db.Integer, db.ForeignKey('graphique.graphId')) graphique = db.relationship("Graphique", backref=db.backref("colonnes", lazy="dynamic")) colName = db.Column(db.String(255)) dateDebut = db.Column(db.Date()) dateFin = db.Column(db.Date()) agregatSimple = db.Column(db.String(255)) capteur_id = db.Column(db.Integer, db.ForeignKey('capteur.captId')) capteur = db.relationship("Capteur") def __repr__(self): return "<Colonne (%d) (%s) >" % (self.numCol, self.colName) @property def aggreger(self): return agregats.get(self.agregatSimple, lambda x: 0) @property def valeurs(self): valeurs = [m.valeur for m in self.capteur.mesures.all()] if not self.agregatSimple: return valeurs else: v = self.aggreger(valeurs) return [v for _ in range(len(self.capteur.mesures.all()))] @property def valeurs_datees(self): return list(zip(self.dates, self.valeurs)) @property def dates(self): return [m.date for m in self.capteur.mesures.all()]
class EventSignup(db.Model): __tablename__ = 'event_signups' event_id = db.Column(db.Integer, db.ForeignKey('events.id'), primary_key=True) user_id = db.Column(db.Integer, db.ForeignKey('users.id'), primary_key=True) created_at = db.Column(db.DateTime(), nullable=False, server_default=db.func.now()) updated_at = db.Column(db.DateTime(), nullable=False, server_default=db.func.now(), onupdate=db.func.now()) @classmethod def find_by_event_and_user(cls, event_id, user_id): return cls.query \ .filter(EventSignup.event_id == event_id) \ .filter(EventSignup.user_id == user_id).first() def delete(self): db.session.delete(self) db.session.commit()
class Label(db.Model): # 1(Task)-to-Many(Label) task_id = db.Column(db.String(80), db.ForeignKey('task.id'), primary_key=True, nullable=False) # 1(Task)-to-Many(User) user_id = db.Column(db.String(80), db.ForeignKey('user.id'), primary_key=True, nullable=False) label_data = db.Column(db.JSON(), nullable=False) # JSON created_at = db.Column(db.DateTime(), nullable=False) def __repr__(self): return f"<Label | task_id : {self.task_id} | user_id : {self.user_id}>" def to_response(self): return { "task_id": self.task_id, "user_id": self.user_id, "label_data": self.label_data, "created_at": self.created_at }
class StaffSalary(db.Model): id = db.Column(db.Integer, primary_key=True) staff_id = db.Column(db.Integer, db.ForeignKey('staff.user_id', ondelete='CASCADE'), nullable=False) datetime = db.Column(db.DateTime, default=datetime.utcnow, nullable=False) amount = db.Column(db.Integer, nullable=False) paid_by = db.Column(db.Integer, db.ForeignKey('staff.user_id'), nullable=False) staff = db.relationship(Staff, backref='salary_info', lazy=True, foreign_keys=[staff_id])
class UserItem(db.Model): __tablename__ = 'user_items' id = db.Column(db.Integer, primary_key=True) user_id = db.Column(db.Integer, db.ForeignKey('users.id')) item_id = db.Column(db.Integer, db.ForeignKey('items.id')) amount = db.Column(db.Integer) item = db.relationship("Item", uselist=False)
class Quantity(db.Model): id = db.Column(db.Integer, primary_key=True) quantity = db.Column(db.Float) recipe_id = db.Column(db.Integer, db.ForeignKey('recipe.id', ondelete="CASCADE"), nullable=False) recipe = db.relationship('Recipe', backref=db.backref('quantities', cascade="all,delete", lazy=True)) ingredient_id = db.Column(db.Integer, db.ForeignKey('ingredient.id'), nullable=False) ingredient = db.relationship('Ingredient', backref=db.backref('quantities', lazy=True)) measurement_id = db.Column(db.Integer, db.ForeignKey('measurement.id'), nullable=False) measurement = db.relationship('Measurement', backref=db.backref('quantities', lazy=True)) def __init__(self, quantity, recipe, ingredient, measurement): self.quantity = quantity self.recipe = recipe self.ingredient = ingredient self.measurement = measurement def __repr__(self): return '<Quantity %r>' % self.quantity
class ClosingDays(ModelBase): __tablename__ = 'closing_days' id = db.Column(db.Integer(), primary_key=True, autoincrement=True) campus_id = db.Column(db.Integer(), db.ForeignKey('campus.id'), nullable=False) first_day = db.Column(db.Date(), nullable=False) last_day = db.Column(db.Date(), nullable=True, server_default=None) translatable_id = db.Column(db.Integer(), db.ForeignKey('translatable.id', onupdate='CASCADE', ondelete='RESTRICT'), nullable=False) def __init__(self, campus_id: int, first_day: datetime.date, last_day: datetime.date, translatable_id: int): if not isinstance(campus_id, int): raise expected('campus_id', campus_id, int) if not isinstance(first_day, datetime.date): raise expected('first_day', first_day, datetime.date) if last_day is not None and not isinstance(last_day, datetime.date): raise expected_or_none('last_day', last_day, datetime.date) if not isinstance(translatable_id, int): raise expected('translatable_id', translatable_id, int) self.campus_id = campus_id self.first_day = first_day self.last_day = last_day self.translatable_id = translatable_id @staticmethod def create(campus: Campus, first_day: datetime.date, last_day: Optional[datetime.date], reason: str, language: str, add_to_db=True) -> 'ClosingDays': translatable, translation = Translatable.get_or_create(reason, language) result = ClosingDays(campus.id, first_day, last_day, translatable.id) if add_to_db: db.session.add(result) return result @staticmethod def find_is_closed(campus: Campus, day: datetime.date) -> 'Optional[ClosingDays]': return ClosingDays.query.filter(db.and_(ClosingDays.campus_id == campus.id, ClosingDays.first_day <= day, db.or_( ClosingDays.last_day == None, ClosingDays.last_day >= day ) )).first() @staticmethod def find_closing_days_including(campus: Campus, start_date: datetime.date, end_date: datetime.date) -> 'List[ClosingDays]': return ClosingDays.query.filter(db.and_(ClosingDays.campus_id == campus.id, ClosingDays.first_day <= end_date, db.or_( ClosingDays.last_day == None, ClosingDays.last_day >= start_date ) )).all()
class Schedule(db.Model): __tablename__ = 'schedule' id = db.Column(db.Integer, primary_key=True) day = db.Column(db.String(30), unique=True, nullable=False) interval_id = db.Column(db.Integer, db.ForeignKey('interval.id')) subject_id = db.Column(db.Integer, db.ForeignKey('subject.id')) lecturer_id = db.Column(db.Integer, db.ForeignKey('lecturer.id')) group_id = db.Column(db.Integer, db.ForeignKey('group.id'))
class Expense(db.Model): id = db.Column(db.Integer, primary_key=True) company_id = db.Column(db.Integer, db.ForeignKey('company.id', ondelete='CASCADE'), nullable=False) status = db.Column(db.Boolean, nullable=False, default=True) amount = db.Column(db.Integer, nullable=False) type = db.Column(db.Integer, db.ForeignKey('expense_type.id'), nullable=False) account = db.Column(db.Integer, db.ForeignKey('payment_method.id', ondelete='CASCADE'), nullable=False) datetime = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
class ReceitaIngrediente(db.Model): __tablename__ = "ReceitaIngrediente" id_receita = db.Column(db.Integer, db.ForeignKey('Receita.id'), primary_key=True) id_ingrediente = db.Column(db.Integer, db.ForeignKey('Ingrediente.id'), primary_key=True) porcentagem = db.Column(db.Float) filho = db.relationship("Ingrediente", back_populates="parentes") parente = db.relationship("Receita", back_populates="filhos")