class ToolDTO(db.Model):
__tablename__ = 'tool'
tool_id = db.Column("tool_id",
db.Integer,
primary_key=True,
autoincrement=True)
name = db.Column(db.String(50), nullable=False)
image = db.Column(db.String(500), nullable=True)
description = db.Column(db.String(500), nullable=True)
quantity = db.Column(db.Integer, default=0)
status = db.Column(db.String(20), nullable=True)
is_deleted = db.Column(db.Boolean(), default=0)
def serialize(self):
return {
"tool_id": self.tool_id,
"name": self.name,
"image": self.image,
"description": self.description,
"quantity": self.quantity,
"status": self.status,
}
def merge(self, newdata):
for key, value in newdata.items():
if value:
setattr(self, key, value)
class User(UserMixin, db.Model):
__tablename__ = "users"
id = db.Column(db.Integer(), primary_key=True)
email = db.Column(db.String(100), unique=True, nullable=False)
name = db.Column(db.String(100), nullable=False)
password = db.Column(db.String(100), nullable=False)
job = db.Column(db.String(150), nullable=True)
class Formula(db.Model):
__tablename__ = 'formula'
name = db.Column(db.String(80), nullable = False)
id = db.Column(db.Integer, primary_key = True)
description = db.Column(db.String(250))
class Song(db.Model):
__tablename__ = 'songs'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(100), unique=True, nullable=False)
artist = db.Column(db.String(100), unique=False, nullable=False)
description = db.Column(db.String(400), unique=False, nullable=True)
path = db.Column(db.String(100), unique=True, nullable=False)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
firstname = db.Column(db.String(64), index=True, unique=False)
lastname = db.Column(db.String(64), index=True, unique=False)
password_hash = db.Column(db.String(128))
recordings = db.relationship('Recording', backref='author', lazy='dynamic')
#auditionee = db.relationship('Audition', backref='auditionee', lazy='dynamic')
def get_info(self):
recordings = self.recordings.all()
scores = []
for r in recordings:
scores.append(r.get_score())
if (len(scores) == 0):
avg = 0
high = 0
else:
avg = np.mean(scores)
high = np.amax(scores)
return {
"firstname": self.firstname,
"lastname": self.lastname,
"top_score": str(round(high, 2)),
"average_score": str(round(avg, 2))
}
def get_recording(self):
recordings = self.recordings.all()
data = []
for r in recordings:
data.append(r.info())
return data
def change_username(self, name):
self.username = name
db.session.commit()
def __repr__(self):
return '<User {}>'.format(self.username)
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 get_ID(self):
return self.id
def get_username(self):
return self.username
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
url = db.Column(db.String(140))
body = db.Column(db.String(140))
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"))
def __repr__(self):
return "<Post {}>".format(self.url)
class Formula(db.Model):
__tablename__ = 'formula'
__table_args__ = {'extend_existing': True}
name = db.Column(db.String(80), nullable=False)
id = db.Column(db.Integer, primary_key=True)
description = db.Column(db.String(250))
instructions = db.Column(db.String(1000))
class User(db.Model, UserMixin):
# usermixin is for user classes only and lets it inherit certain properties
# inheriting will allow us to use different login extensions
# each of these columns represents a data input from user registration
id = db.Column(db.Integer, primary_key=True)
# each user gets a unique ID to identify them
username = db.Column(db.String(), unique=True, nullable=False)
# everyone must have a username, and no one can have the same username as another (same with email)
password = db.Column(db.String(), nullable=False)
class User(db.Model):
__tablename__ = 'user'
name = db.Column(db.String(80), nullable = False)
id = db.Column(db.Integer, primary_key = True)
title = db.Column(db.String(80))
user_creator = db.Column(db.Boolean, default = True)
def get_id(self):
return self.id
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
plays = db.Column(db.Integer, default=0)
url = db.Column(db.String(140))
body = db.Column(db.String(140))
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"))
def __repr__(self):
return "\n{} - https://www.youtube.com/watch?v={}\n".format(
self.body, self.url)
def get_plays(self):
return self.plays
def increment_play_count(self):
self.plays += 1
return
def delete_all():
posts = Post.get_posts()
for post in posts:
db.session.delete(post)
db.session.commit()
return redirect(url_for("index"))
def delete(id):
post = Post.get_post(id)
db.session.delete(post)
db.session.commit()
return
def create(url, body):
post = Post(user_id=current_user.id, url=url, body=body)
db.session.add(post)
db.session.commit()
return
def update(id, url, body):
post = Post.get_post(id)
post.url = url
post.body = body
db.session.add(post)
db.session.commit()
return
def get_post(id):
return Post.query.get_or_404(id)
def get_posts():
return Post.query.order_by(Post.id).all()
class News(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
news_date = db.Column(
db.DateTime,
nullable=False,
default=pytz.timezone('America/Los_Angeles').localize(
datetime.datetime.now()))
image_file = db.Column(db.String(20))
content = db.Column(db.Text, nullable=False)
def __repr__(self):
return f"News('{self.title}', '{self.news_date}')"
class Todo(db.Model):
id = db.Column(db.Integer, primary_key=True)
content = db.Column(db.String(200), nullable=False)
completed = db.Column(db.Integer, default=0)
date_create = db.Column(db.DateTime, default=datetime.utcnow)
def __repr__(self):
return '<Task %r>' % self.id
class Setup(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False)
period_of_res = db.Column(db.Integer, nullable=False)
max_res_for_week = db.Column(db.Integer,
nullable=False) #Currently not in use
is_virtual = db.Column(db.Boolean(), nullable=False, default=False)
product_id = db.Column(db.String(150), nullable=False)
product_serial = db.Column(db.String(150), unique=True, nullable=False)
owner_id = db.Column(db.Integer,
db.ForeignKey('experiment.id'),
nullable=False)
reservations = db.relationship('Reservation',
backref='owner',
lazy='dynamic')
def setup_user_creator(self):
os.system(
f'sudo useradd -m -d /home/setup{self.id} -s /bin/bash setup{self.id}'
)
os.system(f'sudo chown -R setup{self.id} /home/setup{self.id}')
os.system(f'sudo chmod -R 750 /home/setup{self.id}')
if self.is_virtual:
os.system(f'sudo usermod -a -G dialout setup{self.id}')
return
self.rule_file(self.product_id, self.product_serial, self.id)
os.system(f'sudo cp 99-setup{self.id}.rules /etc/udev/rules.d/')
os.system(f'sudo udevadm control --reload-rules && udevadm trigger')
os.remove(f'99-setup{self.id}.rules')
def setup_user_delete(self):
if not self.is_virtual:
os.system(f'sudo rm /etc/udev/rules.d/99-setup{self.id}.rules')
os.system(f'sudo userdel -r setup{self.id}')
@staticmethod
def rule_file(product_id, product_serial, setup_id):
text = []
text.append(
f'SUBSYSTEM=="tty", ATTRS{{idProduct}}=="{product_id}", ATTRS{{serial}}=="{product_serial}", ACTION=="add", RUN+="/bin/setfacl -m u:setup{setup_id}:rw- /dev/$name"'
)
with open(f'99-setup{setup_id}.rules', 'w') as f:
f.writelines(text)
def __repr__(self):
return f"Setup('{self.name}','{self.period_of_res}','{self.max_res_for_week}','{self.owner_id}')"
class ActorDTO(db.Model):
__tablename__ = 'actor'
actor_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(50), nullable=False)
image = db.Column(db.String(500), nullable=True)
description = db.Column(db.String(500), nullable=True)
phone = db.Column(db.String(20), nullable=False)
email = db.Column(db.String(50), nullable=False)
password = db.Column(db.String(20), nullable=False, default='123')
role = db.Column(db.String(5), nullable=False, default='actor')
is_deleted = db.Column(db.Boolean(), default=False)
def serialize(self):
return {
"actor_id": self.actor_id,
"name": self.name,
"image": self.image,
"description": self.description,
"phone": self.phone,
"email": self.email,
"role": self.role,
}
def merge(self, newdata):
for key, value in newdata.items():
if value:
setattr(self, key, value)
class Material(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False)
owner_id = db.Column(db.Integer,
db.ForeignKey('experiment.id'),
nullable=False)
def __repr__(self):
return f"Material('{self.name}','{self.owner_id}')"
class Course(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), unique=True, nullable=False)
experiments = db.relationship('Experiment',
backref='owner',
lazy='dynamic')
def __repr__(self):
return f"Course('{self.name}')"
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(30), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(120), nullable=False)
password_sha1 = db.Column(db.String(120), nullable=False)
is_admin = db.Column(db.Boolean(), nullable=False, default=False)
reservations = db.relationship('Reservation',
backref='owner_student',
lazy='dynamic')
classes = db.relationship(
'Course',
secondary=subs,
backref=db.backref('students_of_class',
lazy='dynamic')) #Currently not in use
def __repr__(self):
return f"User('{self.username}','{self.email}')"
class User(db.Model):
__tablename__ = 'user'
__table_args__ = {'extend_existing': True}
name = db.Column(db.String(80), nullable=False)
id = db.Column(db.Integer, primary_key=True)
password = db.Column(db.String(80), nullable=True, default=id)
user_name = db.Column(db.String(80), nullable=True, default=name)
title = db.Column(db.String(80))
user_creator = db.Column(db.Boolean, default=True)
def get_password(self):
return self.password
class TribulationDTO(db.Model):
__tablename__ = 'tribulation'
tribulation_id = db.Column(db.Integer,
primary_key=True,
autoincrement=True)
name = db.Column(db.String(100), nullable=False)
description = db.Column(db.String(500), nullable=True)
address = db.Column(db.String(200), nullable=True)
time_start = db.Column(db.DateTime, default=datetime.utcnow)
time_end = db.Column(db.DateTime, default=datetime.utcnow)
times = db.Column(db.Integer, default=1)
url_file = db.Column(db.String(200), nullable=True)
actor = db.relationship(ActorDTO,
secondary='character',
backref="tribulation")
tool = db.relationship(ToolDTO,
secondary='tool_for_tribulation',
backref="tribulation")
is_deleted = db.Column(db.Boolean(), default=0)
def serialize(self):
actor = [a.serialize() for a in self.actor]
tool = [t.serialize() for t in self.tool]
time_start = self.time_start.strftime("%Y-%m-%d")
time_end = self.time_end.strftime("%Y-%m-%d")
return {
"tribulation_id": self.tribulation_id,
"name": self.name,
"description": self.description,
"address": self.address,
"time_start": time_start,
"time_end": time_end,
"times": self.times,
"url_file": self.url_file,
"actor": actor,
"tool": tool
}
def merge(self, newdata):
for key, value in newdata.items():
if key != "_sa_instance_state":
print('va: ', value)
setattr(self, key, value)
class Experiment(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False)
owner_id = db.Column(db.Integer,
db.ForeignKey('course.id'),
nullable=False)
setups = db.relationship('Setup', backref='owner', lazy='dynamic')
materials = db.relationship('Material', backref='owner', lazy='dynamic')
def __repr__(self):
return f"Experiment('{self.name}','{self.owner_id}')"
class Event(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
event_date = db.Column(db.DateTime, nullable=False)
event_end = db.Column(db.DateTime)
content = db.Column(db.Text, nullable=False)
def __repr__(self):
return self.event_date.strftime('%m')
class Users(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column('id',
db.Integer,
primary_key=True,
nullable=False,
autoincrement=True)
firstName = db.Column('first_name', db.String(50), nullable=False)
lastName = db.Column('last_name', db.String(50), nullable=False)
email = db.Column('email', db.String(50), nullable=False)
passHash = db.Column('pass_hash', db.String(60), nullable=False)
accountConfirmed = db.Column('account_confirmed',
db.String(1),
nullable=False,
default='F')
dateAdded = db.Column('date_added',
db.String(10),
default=datetime.now().strftime("%m_%d_%Y"))
def __init__(self, firstName, lastName, email, passHash):
self.firstName = firstName
self.lastName = lastName
self.email = email
self.passHash = passHash
def __repr__(self):
return f"User('{self.id}', '{self.firstName}', '{self.lastName}',"\
f"'{self.email}', '{self.dateAdded}')"
class Audition(db.Model):
id = db.Column(db.Integer, primary_key=True)
score = db.Column(db.Float)
scale = db.Column(db.String(64), index=False, unique=False)
key = db.Column(db.String(64), index=False, unique=False)
is_completed = db.Column(db.Boolean, default=False)
auditioner = db.Column(db.String(64), index=False, unique=False)
auditionee = db.Column(db.String(64), index=False, unique=False)
def complete(self):
self.is_completed = True
db.session.commit()
def set_score(self, score):
self.score = score
db.session.commit()
def get_score(self):
return self.score
def get_scale(self):
return self.scale
def get_key(self):
return self.key
def get_auditioner(self):
return self.auditioner
def get_ID(self):
return self.id
def get_auditionee(self):
return self.auditionee
def get_complete(self):
return self.is_completed
class LogDTO(db.Model):
__tablename__ = 'log'
user_id = db.Column(db.Integer, db.ForeignKey('actor.actor_id'), primary_key = True)
date_create = db.Column(db.DateTime,default = datetime.utcnow, primary_key = True)
action = db.Column(db.String(100), nullable = True)
user = db.relationship(ActorDTO)
def serialize(self):
return {
"user_id": self.user_id,
"user_name": self.user.name,
"date_create": self.date_create,
"action": self.action,
}
class Recording(db.Model):
id = db.Column(db.Integer, primary_key=True)
score = db.Column(db.Float)
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
scale = db.Column(db.String(64), index=False, unique=False)
key = db.Column(db.String(64), index=False, unique=False)
def get_score(self):
return self.score
def __repr__(self):
return '<recording {}>'.format(self.score)
def info(self):
return (str(self.timestamp), str(self.score))
def get_scale(self):
return str(scale)
def get_key(self):
return str(key)
class CharacterDTO(db.Model):
__tablename__ = 'character'
character_name = db.Column(db.String(80), nullable = False)
actor_id = db.Column(db.Integer, db.ForeignKey('actor.actor_id'), primary_key = True)
tribulation_id = db.Column(db.Integer, db.ForeignKey('tribulation.tribulation_id'), primary_key = True)
class User(UserMixin, db.Model):
""" The User database object model.
The Flask-Login extension expects that the class used to represent users implements the following properties and methods:
a. is_authenticated
- This property should return True if the user is authenticated, i.e. they have provided valid credentials. (Only authenticated users will fulfill the criteria of login_required.)
b. is_active
- This property should return True if this is an active user - in addition to being authenticated, they also have activated their account, not been suspended, or any condition your application has for rejecting an account. Inactive accounts may not log in (without being forced of course).
c. is_anonymous
- This property should return True if this is an anonymous user. (Actual users should return False instead.)
d. get_id()
- This method must return a unicode that uniquely identifies this user, and can be used to load the user from the user_loader callback. Note that this must be a unicode - if the ID is natively an int or some other type, you will need to convert it to unicode.
e. These are inherited from the [`UserMixin`](https://flask-login.readthedocs.io/en/latest/#flask_login.UserMixin) class.
f. [`db.Model`](https://flask-sqlalchemy.palletsprojects.com/en/2.x/api/#models) q
1. What does db.relationship() do? That function returns a new property that can do multiple things. In this case we told it to point to the Post class and load multiple of those. How does it know that this will return more than one post? Because SQLAlchemy guesses a useful default from your declaration. If you would want to have a one-to-one relationship you can pass uselist=False to relationship() (this would create a one-to-one relationship).
"""
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)
about_me = db.Column(db.String(140))
last_seen = db.Column(db.DateTime, default=datetime.utcnow)
password_hash = db.Column(db.String(128))
poster = db.Column(db.Boolean, unique=False, default=False)
posts = db.relationship("Post", backref="author", 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 __repr__(self):
return "<User {}>".format(self.username)
def set_poster(self, status):
self.poster = status
def is_poster(self):
return self.poster
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 avatar(self, size):
digest = md5(self.email.lower().encode("utf-8")).hexdigest()
return "https://www.gravatar.com/avatar/{}?d=identicon&s={}".format(
digest, size)
def follow(self, user):
if not self.is_following(user):
self.followed.append(user)
def unfollow(self, user):
if self.is_following(user):
self.followed.remove(user)
def is_following(self, user):
return self.followed.filter(
followers.c.followed_id == user.id).count() == 1
def followers(self):
follower_posts = (Post.query.join(
followers, (followers.c.follower_id == Post.user_id)).filter(
followers.c.followed_id == self.id).all())
return set([
User.query.filter_by(id=post.user_id).first()
for post in follower_posts
])
def followed_users(self):
followed = (Post.query.join(
followers, (followers.c.followed_id == Post.user_id)).filter(
followers.c.follower_id == self.id).all())
return set([
User.query.filter_by(id=post.user_id).first() for post in followed
])
def followed_posts(self):
followed = Post.query.join(
followers, (followers.c.followed_id == Post.user_id)).filter(
followers.c.follower_id == self.id)
own = Post.query.filter_by(user_id=self.id)
return followed.union(own).order_by(Post.timestamp.desc())
class User(UserMixin, db.Model):
""" The User database object model.
The Flask-Login extension expects that the class used to represent users implements the following properties and methods:
a. is_authenticated
- This property should return True if the user is authenticated, i.e. they have provided valid credentials. (Only authenticated users will fulfill the criteria of login_required.)
b. is_active
- This property should return True if this is an active user - in addition to being authenticated, they also have activated their account, not been suspended, or any condition your application has for rejecting an account. Inactive accounts may not log in (without being forced of course).
c. is_anonymous
- This property should return True if this is an anonymous user. (Actual users should return False instead.)
d. get_id()
- This method must return a unicode that uniquely identifies this user, and can be used to load the user from the user_loader callback. Note that this must be a unicode - if the ID is natively an int or some other type, you will need to convert it to unicode.
e. These are inherited from the [`UserMixin`](https://flask-login.readthedocs.io/en/latest/#flask_login.UserMixin) class.
f. [`db.Model`](https://flask-sqlalchemy.palletsprojects.com/en/2.x/api/#models) q
1. What does db.relationship() do? That function returns a new property that can do multiple things. In this case we told it to point to the Post class and load multiple of those. How does it know that this will return more than one post? Because SQLAlchemy guesses a useful default from your declaration. If you would want to have a one-to-one relationship you can pass uselist=False to relationship() (this would create a one-to-one relationship).
"""
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)
about_me = db.Column(db.String(140))
twitter = db.Column(db.String(140))
instagram = db.Column(db.String(140))
github = db.Column(db.String(140))
profile_picture_url = db.Column(db.String(140))
last_seen = db.Column(db.DateTime, default=datetime.utcnow)
password_hash = db.Column(db.String(128))
poster = db.Column(db.Boolean, unique=False, default=False)
admin = db.Column(db.Boolean, unique=False, default=False)
receives_mail = db.Column(db.Boolean, unique=False, default=False)
authenticated = db.Column(db.Boolean, unique=False, default=False)
posts = db.relationship("Post", backref="author", 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 forgot_password(email):
user = User.query.filter_by(email=email).first()
rand_string = "".join(
random.choice(string.ascii_uppercase + string.digits)
for _ in range(10))
user.set_password(rand_string)
db.session.add(user)
db.session.commit()
msg = Message("Your Temporary Password",
sender="*****@*****.**",
recipients=[email])
msg.body = (
"Your temporary password is: " + rand_string +
".\n Make sure to reset your password when you log back in!")
mail.send(msg)
return
def __repr__(self):
return "<User {}>".format(self.username)
def set_poster(self, status):
self.poster = status
return
def is_poster(self):
return self.poster
def set_mail_status(self, status):
self.receives_mail = status
return
def get_mail_status(self):
return self.receives_mail
def is_admin(self):
return self.admin
def set_admin(self, status):
self.admin = status
return
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 avatar(self, size):
digest = md5(self.email.lower().encode("utf-8")).hexdigest()
return "https://www.gravatar.com/avatar/{}?d=identicon&s={}".format(
digest, size)
def follow(self, user):
if not self.is_following(user):
self.followed.append(user)
return
def unfollow(self, user):
if self.is_following(user):
self.followed.remove(user)
return
def is_following(self, user):
return self.followed.filter(
followers.c.followed_id == user.id).count() == 1
def followers(self):
follower_posts = (Post.query.join(
followers, (followers.c.follower_id == Post.user_id)).filter(
followers.c.followed_id == self.id).all())
return set([
User.query.filter_by(id=post.user_id).first()
for post in follower_posts
])
def followed_users(self):
followed = (Post.query.join(
followers, (followers.c.followed_id == Post.user_id)).filter(
followers.c.follower_id == self.id).all())
return set([
User.query.filter_by(id=post.user_id).first() for post in followed
])
def followed_posts(self):
followed = Post.query.join(
followers, (followers.c.followed_id == Post.user_id)).filter(
followers.c.follower_id == self.id)
own = Post.query.filter_by(user_id=self.id)
return followed.union(own).order_by(Post.timestamp.desc())
def delete_all():
if not current_user.admin:
return "There Was An Error!"
users = User.get_users()
for user in users:
if not user.admin:
db.session.delete(user)
db.session.commit()
return
def delete(id):
user = User.query.get_or_404(id)
if not user.admin:
db.session.delete(user)
db.session.commit()
return redirect(url_for("admin"))
def get_user(id):
return User.query.get_or_404(id)
def get_users():
return User.query.order_by(User.username).all()
def get_posts(self):
return self.posts
def get_post(id):
return Post.get_post(id)
def signed_in(self):
return self.authenticated
def send_weekly_newsletter():
recipients = User.get_users()
recipients_emails = []
post_urls = []
for user in recipients:
recipients_emails.append(user.email)
if len(user.get_posts().all()) > 0:
posts = user.get_posts().all()
for post in posts:
if (datetime.utcnow() -
post.timestamp) > timedelta(days=1):
post_urls.append(post)
msg = Message(
"Joe Damiba's Playlist This Week",
sender="*****@*****.**",
recipients=recipients_emails,
)
msg.body = str(post_urls)
mail.send(msg)
return
