class Customer(db.Model, UserMixin): id = db.Column(db.Integer, primary_key=True) customer_id = db.Column(db.String(50), unique=True, nullable=False) email = db.Column(db.String(80), unique=True) password = db.Column(db.String(80), nullable=False) name = db.Column(db.String(50), nullable=False) contact_one = db.Column(db.String(20), nullable=False) contact_two = db.Column(db.String(20)) admin = db.Column(db.Boolean, default=False) const_house_no = db.Column(db.Text, nullable=False) const_landmark = db.Column(db.Text, nullable=False) const_locality = db.Column(db.Text, nullable=False) const_city = db.Column(db.String(50), nullable=False) const_state = db.Column(db.Text, nullable=False) const_pincode = db.Column(db.Integer, nullable=False) delivery_house_no = db.Column(db.Text, nullable=False) delivery_landmark = db.Column(db.Text, nullable=False) delivery_locality = db.Column(db.Text, nullable=False) delivery_city = db.Column(db.String(50), nullable=False) delivery_state = db.Column(db.Text, nullable=False) delivery_pincode = db.Column(db.Integer, nullable=False) latitude = db.Column(db.String(60), nullable=False, default='00.00') longitude = db.Column(db.String(60), nullable=False, default='00.00') device_id = db.Column(db.String(180), nullable=False, default='key') cart_items = db.relationship('Cart', cascade='all,delete', backref='customer_cart', lazy=True) fav_items = db.relationship('Favourites', cascade='all,delete', backref='customer_fav', lazy=True)
class EventType(db.Model, BaseModel): __bind_key__ = 'term' __tablename__ = 'event_type' id = db.Column(db.Integer, primary_key=True) term_type = db.Column(db.Integer, db.ForeignKey('term.id')) term = db.relationship('Term') event_id = db.Column(db.Integer, db.ForeignKey('event.id')) event = db.relationship('Event') @staticmethod def get_types(term_type=False): if isinstance(term_type, (bool)): return EventType.query.all() return EventType.query.filter_by(term_type=term_type).all() @staticmethod def get_dict(term_type=False): from models.event import Event types = EventType.get_types(term_type) events = Event.get_dict() result = {} for row in types: result[row.event_id] = events[row.event_id] return result
class ReferralToCourses(db.Model): __tablename__ = "referral_to_courses" referral_number = db.Column(db.Integer, primary_key=True) proff_course_start_date = db.Column(db.Date, nullable=False) proff_course_end_date = db.Column(db.Date, nullable=False) sertificate = db.Column(db.Boolean, nullable=False) personnel_number = db.Column(db.Integer, db.ForeignKey('teacher.personnel_number', onupdate="CASCADE", ondelete="CASCADE"), nullable=False) teacher = db.relationship("Teacher", back_populates="referral_to_courses") selective_course_date = db.relationship( "SelectiveCourseDate", back_populates="referral_to_courses") def __init__(self, referral_number, proff_course_start_date, proff_course_end_date, sertificate, personnel_number): self.referral_number = referral_number self.proff_course_start_date = datetime.strptime( proff_course_start_date, '%Y-%m-%d').date() self.proff_course_end_date = datetime.strptime(proff_course_end_date, '%Y-%m-%d').date() self.sertificate = sertificate if sertificate else False self.personnel_number = personnel_number
class User(UserMixin, db.Model): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(64), index=True, unique=True) email = db.Column(db.String(120), index=True, unique=True) password_hash = db.Column(db.String(128)) ticker_per_page = db.Column(db.Integer, default=3) activated = db.Column(db.Boolean, default=False) tasks = db.relationship('Task', backref='user', lazy='dynamic') subscriptions = db.relationship('TickerSubscription', backref='user', lazy='dynamic') # followed = db.relationship( # 'User', secondary=followers, # primaryjoin=(followers.c.follower_id == id), # secondaryjoin=(followers.c.followed_id == id), # backref=db.backref('followers', lazy='dynamic'), lazy='dynamic') def set_password(self, password): self.password_hash = generate_password_hash(password) def check_password(self, password): return check_password_hash(self.password_hash, password) def __repr__(self): return '<User {}>'.format(self.username)
class UserRoles(db.Model): __tablename__ = 'user_roles' id = db.Column(db.Integer(), primary_key=True) user_id = db.Column(db.Integer(), db.ForeignKey('user.id', ondelete='CASCADE')) user = db.relationship('User') role_id = db.Column(db.Integer(), db.ForeignKey('role.id', ondelete='CASCADE')) user = db.relationship('Role')
class User(UserMixin, db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(64), index=True, unique=True) email = db.Column(db.String(128), index=True, unique=True) password_hash = db.Column(db.String(128)) language = db.Column(db.String(2), default='en') credentials = db.relationship('AccountCredential', backref='owner', lazy='dynamic') scan_profiles = db.relationship('ScanProfile', backref='owner', lazy='dynamic') tasks = db.relationship('Task', backref='owner', lazy='dynamic') results = db.relationship('TaskResult', backref='owner', lazy='dynamic', order_by='desc(TaskResult.started)') def set_password(self, password: str) -> None: self.password_hash = generate_password_hash(password) def check_password(self, password: str) -> bool: return check_password_hash(self.password_hash, password) def __repr__(self) -> str: return f'User({self.username})'
class StudyGroup(db.Model): __tablename__ = 'study_groups' id = db.Column(db.Integer, primary_key=True, autoincrement=True) start_date = db.Column(db.Date, nullable=False) end_date = db.Column(db.Date, nullable=False) name_format = db.Column(db.String(6), nullable=False) elder_id = db.Column(db.Integer, db.ForeignKey('students.person_id')) department_id = db.Column(db.Integer, db.ForeignKey('departments.id'), nullable=False) students = db.relationship('Student', foreign_keys='Student.group_id', backref='group', uselist=True) lessons = db.relationship('Lesson', backref='group', uselist=True) def save(self): db.session.add(self) db.session.commit() def format_name(self): now = date.today() if now < self.end_date: return self.name_format.replace('*', str(now.year - self.start_date.year + 1)) else: return '—' def get_elder(self): if self.elder_id is None: return None return Student.get(id=self.elder_id) def get_lessons(self, week_day=None, is_week_even=None): if week_day is None and is_week_even is None: return sorted(self.lessons, key=lambda l: (l.week_day, l.start_time)) else: lessons = self.lessons if week_day is not None: lessons = [l for l in lessons if l.week_day == week_day] if is_week_even is not None: lessons = [l for l in lessons if (l.on_even_week == 'u') or (l.on_even_week == is_week_even)] return sorted(lessons, key=lambda l: (l.week_day, l.start_time)) @staticmethod def get_all(): return StudyGroup.query.all() @staticmethod def get_by_name(name): all = StudyGroup.query.all() filtered = filter(lambda group: name == group.format_name(), all) return list(filtered) @staticmethod def get(id=None, name_format=None, department_id=None): if id is not None: return StudyGroup.query.filter_by(id=id).first() if name_format is not None: return StudyGroup.query.filter_by(name_format=name_format).first() if id is not None: return StudyGroup.query.filter_by(department_id=department_id).all()
class AlarmStack(db.Model, BaseModel): __bind_key__ = 'stack' __tablename__ = 'alarm_stack' DEFAULT_COUNT = 1 DEFAULT_INTERVAL = 86400 LOCK_FREE = 0 LOCK_SET = 1 id = db.Column(db.Integer, primary_key=True) firm_id = db.Column(db.Integer, db.ForeignKey('firm.id')) firm = db.relationship('Firm') term_id = db.Column(db.Integer, db.ForeignKey('term.id')) term = db.relationship('Term') emails = db.Column(db.Text, nullable=False) interval = db.Column(db.Integer, nullable=False) count = db.Column(db.Integer, nullable=False) lock = db.Column(db.Integer, index=True, nullable=False) def __init__(self, firm_id=None, term_id=None): self.lock = self.LOCK_FREE self.interval = self.DEFAULT_INTERVAL self.count = self.DEFAULT_COUNT self.term_id = term_id self.firm_id = firm_id def get_term_alarm(self): alarm = AlarmStack.query.filter_by(term_id=self.term_id, firm_id=self.firm_id).first() if not alarm: alarm = self m, s = divmod(alarm.interval, 60) h, m = divmod(m, 60) alarm.interval = "%d:%02d" % (h, m) return alarm @staticmethod def reset_count(term_id): result = False alarm = AlarmStack.query.filter_by(term_id=term_id).first() if not alarm: return result alarm.count = AlarmStack.DEFAULT_COUNT if alarm.save(): result = True return result def save(self): self.emails = self.encode_field(self.emails) return BaseModel.save(self)
class EducationalOrganization(db.Model): __tablename__ = 'edu_orgs' id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(132), nullable=False, unique=True) short_name = db.Column(db.String(10), nullable=False) departments = db.relationship('Department', backref='edu_org') classrooms = db.relationship('Classroom', backref='edu_org') def __init__(self, name, short_name): self.name = name self.short_name = short_name def save(self): db.session.add(self) db.session.commit() def get_department(self, name=None, short_name=None): if name is not None: name = name.lower() filtered = filter(lambda d: d.name.lower() == name, self.departments) elif short_name is not None: short_name = short_name.lower() filtered = filter(lambda d: d.short_name.lower() == short_name, self.departments) filtered = list(filtered) if len(filtered) > 1: raise DepartmentIsNotUniqueException('More than one department for a educational organization with definite name') elif len(filtered) == 1: return filtered[0] else: return None def get_classroom(self, name): name = name.lower() classrooms = filter(lambda c: c.get_name().lower() == name.lower(), self.classrooms) classrooms = list(classrooms) if len(classrooms) > 1: raise ClassroomIsNotUniqueException('More than one group for a department with definite name') elif len(classrooms) == 1: return classrooms[0] else: return None @staticmethod def get_all(): return EducationalOrganization.query.all() @staticmethod def get(id=None, name=None, short_name=None): if id is not None: return EducationalOrganization.query.filter_by(id=id).first() if name is not None: return EducationalOrganization.query.filter_by(name=name).first() if short_name is not None: return EducationalOrganization.query.filter_by(short_name=short_name).all() return None
class Task(db.Model): __table_args__ = (db.UniqueConstraint('name', 'owner_id', name='task_uniq'), ) id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(64), index=True) status = db.Column( db.Enum(TaskStatus), default=TaskStatus.Idle, server_default=TaskStatus.Idle.name, nullable=False, ) uid = db.Column(db.String(128)) owner_id = db.Column(db.Integer, db.ForeignKey('users.id', name='task_fk', ondelete='CASCADE'), nullable=False) settings = db.relationship('TaskSetting', backref='task', lazy='dynamic') results = db.relationship('TaskResult', backref='task', lazy='dynamic', order_by='TaskResult.started') def to_list(self) -> List: return [ dict(address=item.hostname, **item.profile.to_dict()) for item in self.settings ] def update_status(self, status: TaskStatus): if status == TaskStatus.Wait: if self.status != TaskStatus.Idle: return self.status = TaskStatus.Wait elif status == TaskStatus.Idle: if self.uid is None: self.status = TaskStatus.Idle return if self.status == TaskStatus.Idle: return self.status = TaskStatus.Idle celery_task = AsyncResult(self.uid) if celery_task: CeleryControl(celery).revoke(self.uid, terminate=True) self.uid = None def __repr__(self): return f'Task(name={self.name})'
class TermUserFirm(db.Model, BaseModel): __bind_key__ = 'term' __tablename__ = 'user_firm' id = db.Column(db.Integer, primary_key=True) user_id = db.Column(db.Integer, db.ForeignKey('term_user.id')) user = db.relationship( 'TermUser', primaryjoin="TermUser.id==TermUserFirm.user_id") firm_id = db.Column(db.Integer, db.ForeignKey('firm.id')) firm = db.relationship('Firm', primaryjoin="Firm.id==TermUserFirm.firm_id")
class RelUserProject(JsonSerializer, db.Model): id = db.Column(db.Integer, primary_key=True) user_id = db.Column(db.Integer, db.ForeignKey("users.id")) project_id = db.Column(db.Integer, db.ForeignKey("projects.id")) created_at = db.Column(db.DateTime, default=db.func.now()) updated_at = db.Column(db.DateTime, default=db.func.now(), onupdate=db.func.now()) user = db.relationship("Users", backref=db.backref("projects", lazy="dynamic")) project = db.relationship("Projects", backref=db.backref("users", lazy="dynamic"))
class TeacherSubject(db.Model): __tablename__ = "teacher_subject" subject_id = db.Column(db.Integer, db.ForeignKey('subject.subject_id', onupdate="CASCADE", ondelete="NO ACTION"), primary_key=True) personnel_number = db.Column(db.Integer, db.ForeignKey('teacher.personnel_number', onupdate="CASCADE", ondelete="CASCADE"), primary_key=True) teacher = db.relationship("Teacher", back_populates="teacher_subject") subject = db.relationship("Subject", back_populates="teacher_subject") def __init__(self, subject_id, personnel_number): self.subject_id = subject_id self.personnel_number = personnel_number
class ScanProfile(db.Model): __table_args__ = (db.UniqueConstraint('name', 'owner_id', name='scan_profile_uniq'), ) id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String) owner_id = db.Column(db.Integer, db.ForeignKey('users.id', name='scan_profile_fk', ondelete='CASCADE'), nullable=False) settings = db.relationship('ProfileSetting', lazy='dynamic', cascade="save-update, delete") def __repr__(self) -> str: return f'ScanProfile(name={self.name})' def to_dict(self) -> Dict[str, Dict[str, str]]: result = defaultdict(dict) for item in self.settings: if item.setting == 'credential': credential = AccountCredential.query.get(item.value) result[item.transport].update( dict(username=credential.username, password=credential.password)) continue result[item.transport][item.setting] = item.value return result
class OutgoingMessage(db.Model): __tablename__ = 'outgoing_messages' id = db.Column(db.Integer, primary_key=True, autoincrement=True) message_id = db.Column(db.Integer, db.ForeignKey('messages.id'), nullable=False) to_id = db.Column(db.Integer, db.ForeignKey('vk_users.vk_id'), nullable=False) message = db.relationship('Message', backref='out_message', uselist=False) def __init__(self, to_id, text): self.to_id = to_id self.text = text def send(self): random_id = VK.send_message(text=self.text, user_id=self.to_id) if random_id is None: return False message = Message( datetime = datetime.utcnow(), random_id = random_id, text = self.text ) message.save() self.message_id = message.id db.session.add(self) db.session.commit() return True
class IncomingMessage(db.Model): __tablename__ = 'incoming_messages' id = db.Column(db.Integer, primary_key=True, autoincrement=True) message_id = db.Column(db.Integer, db.ForeignKey('messages.id'), nullable=False) from_id = db.Column(db.Integer, db.ForeignKey('vk_users.vk_id'), nullable=False) message = db.relationship('Message', backref='inc_message', uselist=False) def save(self, message): send_date = datetime.strptime( time.ctime(message['date']), '%a %b %d %H:%M:%S %Y' ) msg_obj = Message( datetime = send_date, random_id = message['random_id'], text = message['text'] ) msg_obj.save() self.message_id = msg_obj.id self.from_id = message['from_id'] db.session.add(self) db.session.commit() def get_text(self): return self.message.get_text()
class Message(db.Model): __tablename__ = 'messages' id = db.Column(db.Integer, primary_key=True, autoincrement=True) datetime = db.Column(db.DateTime, nullable=False) random_id = db.Column(db.Integer, nullable=False) text = db.Column(db.String(1000), nullable=False) long_text = db.relationship('LongText', backref='message', uselist=False) def save(self): text = self.text self.text = text[:1000] long_text = None db.session.add(self) db.session.commit() if len(text) > 1000: long = LongText(text=text, message_id=self.id) long.save() self.long_text = long db.session.add(self) db.session.commit() def format_datetime(self): return format_datetime(self.datetime) def get_text(self): if self.long_text is not None: return self.long_text.text return self.text
class Hotel(db.Model): url = db.Column(db.String(500)) id = db.Column(db.Integer, primary_key=True) crawledAt = db.Column(db.DateTime) priority = db.Column(db.Integer) vacation = db.relationship('Vacation') localityId = db.Column(db.Integer, db.ForeignKey('locality.id')) locality = db.relationship('Locality', enable_typechecks=False) def __init__(self, id, locality): self.id = id self.url = '-' self.locality = locality def __repr__(self): return 'Hotel ' + str(self.id)
class Vacation(db.Model): url = db.Column(db.String(500), primary_key=True) createdAt = db.Column(db.String(50), primary_key=True) term = db.Column(db.String(50)) locationFrom = db.Column(db.String(50)) food = db.Column(db.String(50)) urlCrawled = db.Column(db.String(500)) days = db.Column(db.String(50)) price = db.Column(db.String(50)) hotelId = db.Column(db.Integer, db.ForeignKey('hotel.id')) hotel = db.relationship('Hotel', enable_typechecks=False) def __init__(self, url, term, locationFrom, food, days, price, urlCrawled, hotel): self.url = url self.createdAt = datetime.utcnow() self.term = term self.locationFrom = locationFrom self.food = food self.days = days self.price = price self.urlCrawled = urlCrawled self.hotel = hotel def __repr__(self): return 'Vacation ' + str(self.createdAt) + str(self.url)
class Classroom(db.Model): __tablename__ = 'classrooms' id = db.Column(db.Integer, primary_key=True, autoincrement=True) edu_org_id = db.Column(db.Integer, db.ForeignKey('edu_orgs.id'), nullable=False) number_format = db.Column(db.String(5), nullable=False) number = db.Column(db.Integer) lessons = db.relationship('Lesson', backref='classroom', uselist=True) def save(self): db.session.add(self) db.session.commit() def get_name(self): return self.number_format.replace('*', str(self.number)) @staticmethod def get_all(): return Classroom.query.all() @staticmethod def get(id=None, name=None): if id is not None: return Classroom.query.filter_by(id=id).first() if name is not None: classrooms = Classroom.get_all() name = name.lower() return [c for c in classrooms if c.get_name().lower() == name]
class Teacher(db.Model): __tablename__ = 'teachers' person_id = db.Column(db.Integer, db.ForeignKey('persons.id'), primary_key=True) department_id = db.Column(db.Integer, db.ForeignKey('departments.id'), nullable=False) subjects = db.relationship('Subject', backref='teacher', uselist=True) def save(self): db.session.add(self) db.session.commit() def get_subject(self, name): name = name.lower() filtered = filter(lambda s: s.name.lower() == name, self.subjects) filtered = list(filtered) if len(filtered) > 1: raise SubjectIsNotUniqueException('More than one subject for a teacher with definite name') elif len(filtered) == 1: return filtered[0] else: return None def get_subject_by_part(self, name): name = name.lower() filtered = filter(lambda s: name in s.name.lower(), self.subjects) return list(filtered) @staticmethod def get_all(): return Teacher.query.all()
class TaskResult(db.Model): id = db.Column(db.Integer, primary_key=True) task_id = db.Column(db.Integer, db.ForeignKey('task.id', name='task_result_fk', ondelete='SET NULL'), nullable=False) owner_id = db.Column(db.Integer, db.ForeignKey('users.id', name='task_fk', ondelete='CASCADE'), nullable=False) started = db.Column(db.DateTime, server_default=func.now()) finished = db.Column(db.DateTime) host_results = db.relationship('HostResult', backref='task', lazy='dynamic', cascade='all, delete-orphan') @property def duration(self) -> Optional[datetime]: if self.finished is None: return return self.finished - self.started def finish(self): self.finished = datetime.utcnow() def __repr__(self): return f'TaskResult(started="{self.started.isoformat()}")'
class User(db.Model): id = db.Column(db.Integer, primary_key=True) login = db.Column(db.String(32), unique=True) #, nullable=False) password = db.Column(db.String(32), unique=False) #, nullable=False) email = db.Column(db.String(128), unique=True) #, nullable=False) date_created = db.Column(db.DateTime, default=db.func.current_timestamp()) verified = db.Column(db.Boolean, default=False) link = db.Column(db.String(32), nullable=True) personalInfo = db.relationship('PersonalInfo', backref='user', uselist=False) def __init__(self, login): self.login = login def save(self, password): """ Функция сохранения нового пользователя в базе данных :param password: Пароль """ self.password = hashlib.sha512( password.encode("utf-8")).hexdigest() db.session.add(self) db.session.commit() def check_pass(self, password): hash = hashlib.sha512(password.encode("utf-8")).hexdigest() return self.password == hash @staticmethod def get(id=None, login=None): if login: return User.query.filter_by(login=login).first() if id: return User.query.get(id) return User.query.all()
class Subject(db.Model): __tablename__ = 'subjects' id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(75), nullable=False) short_name = db.Column(db.String(10), nullable=False) teacher_id = db.Column(db.Integer, db.ForeignKey('teachers.person_id'), nullable=False) lessons = db.relationship('Lesson', backref='subject', uselist=True) def save(self): db.session.add(self) db.session.commit() @staticmethod def get_all(): return Subject.query.all() @staticmethod def get(id=None, name=None): if id is not None: return Subject.query.filter_by(id=id).first() if name is not None: subjects = Subject.query.all() name = name.lower() return [s for s in subjects if name.lower() in s.name.lower()]
class Raspberry(db.Model, Base): id: int updateAt: datetime name: str name = db.Column(db.String, nullable=True) hardwares = db.relationship("Hardware", backref="raspberry", lazy='dynamic') users = db.relationship('User', secondary=RaspberryUser, back_populates='raspberries', lazy='joined') def __hash__(self): return hash(self.id)
class ExtraApplication(db.Model): __tablename__ = "extra_application" extra_application_number = db.Column(db.Integer, primary_key=True, autoincrement=True) extra_application_date = db.Column(db.Date, nullable=False) extra_application_reason = db.Column(db.String(1500), nullable=False) extra_application_status = db.Column(db.String(50), nullable=False) teacher_position = db.Column(db.String(100), nullable=False) teacher_pib = db.Column(db.String(100), nullable=False) personnel_number = db.Column(db.Integer, db.ForeignKey('teacher.personnel_number', onupdate="CASCADE", ondelete="CASCADE"), nullable=False) teacher = db.relationship("Teacher", back_populates="extra_application") def __init__(self, extra_application_reason, extra_application_date, extra_application_status, teacher_position, teacher_pib, personnel_number): self.extra_application_date = datetime.strptime( extra_application_date, '%Y-%m-%d').date() self.extra_application_reason = extra_application_reason self.extra_application_status = STATUS[extra_application_status].value self.teacher_position = teacher_position self.teacher_pib = teacher_pib self.personnel_number = personnel_number
class Alias(db.Model): id = db.Column(db.Integer, primary_key=True) owner_id = db.Column(db.Integer, db.ForeignKey('user.id')) domain_id = db.Column(db.Integer, db.ForeignKey('domain.id')) alias = db.Column(db.String(255), index=True, nullable=False) forward = db.Column(db.String(255), nullable=False) comment = db.Column(db.Text, default='') enabled = db.Column(db.Boolean, default=True) expires = db.Column(db.DateTime, default=None) num_accepted = db.Column(db.Integer, default=0) num_rejected = db.Column(db.Integer, default=0) domain = db.relationship('Domain', backref=db.backref('aliases', lazy=True)) owner = db.relationship('User', backref=db.backref('aliases'))
class Book(db.Model): __tablename__ = _TABLE_BOOKS id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String) genre = db.Column(db.String) authors = db.relationship('Author', secondary='books_authors', back_populates='books') def __init__(self, title, genre, authors): self.title = title self.genre = genre self.authors = authors def __repr__(self): return "Book #{0}: {1} ({2}) - {3}.".format(self.id, self.title, self.genre, self.authors) @property def to_dict(self): return {'id': self.id, 'title': self.title, 'genre': self.genre, 'authors': self.serialize_authors} @property def serialize_authors(self): authors_list = map(str, self.authors) return ','.join(authors_list)
class Brand(db.Model): id = db.Column(db.Integer, primary_key=True) nike = db.Column(db.String, nullable=False) adidas = db.Column(db.String, nullable=False) merrel = db.Column(db.String, nullable=False) gucci = db.Column(db.String, nullable=False) sheckhers = db.Column(db.String, nullable=False) product = db.relationship('Productdetail', backref='brand', lazy=True)
class Director(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(64), index=True, unique=True) extras = db.Column(db.String(128)) movies = db.relationship('Movie', backref='writer', lazy='dynamic') def __repr__(self): return '<Director {}>'.format(self.name)