from app import\
	db,\
	app
from datetime import\
	datetime
from werkzeug.security import\
	generate_password_hash,\
	check_password_hash
from flask_login import\
	UserMixin
from app import\
	login
from hashlib import\
	md5
import jwt
from time import\
	time
followers=db.Table(
	'followers',
	db.Column('follower_id',db.Integer,db.ForeignKey('user.id')),
	db.Column('followed_id',db.Integer,db.ForeignKey('user.id'))
)
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))
	about_me=db.Column(db.String(140))
	last_seen=db.Column(db.DateTime,default=datetime.utcnow)
	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_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()>0
	def followed_posts(self):
		return Post.query.join(
			followers,(followers.c.followed_id==Post.user_id)
		).filter(
			followers.c.follower_id==self.id
		).order_by(
			Post.timestamp.desc()
		)
	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 get_reset_password_token(self, expires_in=600):
		return jwt.encode(
		    {'reset_password': self.id, 'exp': time() + expires_in},
		    app.config['SECRET_KEY'], algorithm='HS256').decode('utf-8')
	@staticmethod
	def verify_reset_password_token(token):
		try:
			id=jwt.decode(
				token,
				app.config['SECRET_KEY'],
				algorithms=['HS256'])['reset_password']
		except:
			return
		return User.query.get(id)
class Post(db.Model):
	id=db.Column(db.Integer,primary_key=True)
	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.body)
class Trajectory(UserMixin,db.Model):
	id=db.Column(db.Integer,primary_key=True)
	YYYY=db.Column(db.Integer)
	MM=db.Column(db.Integer)
	DD=db.Column(db.Integer)
	VENAU=db.Column(db.Float)
	SECLAT=db.Column(db.Float)
	SECLON=db.Column(db.Float)
class Cpu(UserMixin,db.Model):
	id=db.Column(db.Integer,primary_key=True)
	ts=db.Column(db.DateTime,default=datetime.utcnow)
	cpu=db.Column(db.String)
class Test(db.Model):
	id=db.Column(db.Integer,primary_key=True)
	ts=db.Column(db.DateTime,default=datetime.utcnow)
	cpu=db.Column(db.String)
@login.user_loader
def load_user(id):
	return User.query.get(int(id))

73c4b3eda3f0d4792ebbb6de96289e0494a4827f
<mask token>


class User(UserMixin, db.Model):
    <mask token>
    <mask token>
    <mask token>
    <mask token>
    <mask token>
    <mask token>
    <mask token>
    <mask token>

    def __repr__(self):
        return '<User {}>'.format(self.username)

    def set_password(self, password):
        self.password_hash = generate_password_hash(password)
    <mask token>

    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)
    <mask token>
    <mask token>
    <mask token>

    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())
    <mask token>
    <mask token>


class Post(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    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.body)


class Trajectory(UserMixin, db.Model):
    id = db.Column(db.Integer, primary_key=True)
    YYYY = db.Column(db.Integer)
    MM = db.Column(db.Integer)
    DD = db.Column(db.Integer)
    VENAU = db.Column(db.Float)
    SECLAT = db.Column(db.Float)
    SECLON = db.Column(db.Float)


class Cpu(UserMixin, db.Model):
    id = db.Column(db.Integer, primary_key=True)
    ts = db.Column(db.DateTime, default=datetime.utcnow)
    cpu = db.Column(db.String)


class Test(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    ts = db.Column(db.DateTime, default=datetime.utcnow)
    cpu = db.Column(db.String)


<mask token>

<mask token>


class User(UserMixin, db.Model):
    <mask token>
    <mask token>
    <mask token>
    <mask token>
    <mask token>
    <mask token>
    <mask token>
    <mask token>

    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 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)
    <mask token>
    <mask token>
    <mask token>

    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 get_reset_password_token(self, expires_in=600):
        return jwt.encode({'reset_password': self.id, 'exp': time() +
            expires_in}, app.config['SECRET_KEY'], algorithm='HS256').decode(
            'utf-8')
    <mask token>


class Post(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    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.body)


class Trajectory(UserMixin, db.Model):
    id = db.Column(db.Integer, primary_key=True)
    YYYY = db.Column(db.Integer)
    MM = db.Column(db.Integer)
    DD = db.Column(db.Integer)
    VENAU = db.Column(db.Float)
    SECLAT = db.Column(db.Float)
    SECLON = db.Column(db.Float)


class Cpu(UserMixin, db.Model):
    id = db.Column(db.Integer, primary_key=True)
    ts = db.Column(db.DateTime, default=datetime.utcnow)
    cpu = db.Column(db.String)


class Test(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    ts = db.Column(db.DateTime, default=datetime.utcnow)
    cpu = db.Column(db.String)


<mask token>

<mask token>


class User(UserMixin, db.Model):
    <mask token>
    <mask token>
    <mask token>
    <mask token>
    <mask token>
    <mask token>
    <mask token>
    <mask token>

    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 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(
            ) > 0

    def followed_posts(self):
        return Post.query.join(followers, followers.c.followed_id == Post.
            user_id).filter(followers.c.follower_id == self.id).order_by(Post
            .timestamp.desc())

    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 get_reset_password_token(self, expires_in=600):
        return jwt.encode({'reset_password': self.id, 'exp': time() +
            expires_in}, app.config['SECRET_KEY'], algorithm='HS256').decode(
            'utf-8')

    @staticmethod
    def verify_reset_password_token(token):
        try:
            id = jwt.decode(token, app.config['SECRET_KEY'], algorithms=[
                'HS256'])['reset_password']
        except:
            return
        return User.query.get(id)


class Post(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    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.body)


class Trajectory(UserMixin, db.Model):
    id = db.Column(db.Integer, primary_key=True)
    YYYY = db.Column(db.Integer)
    MM = db.Column(db.Integer)
    DD = db.Column(db.Integer)
    VENAU = db.Column(db.Float)
    SECLAT = db.Column(db.Float)
    SECLON = db.Column(db.Float)


class Cpu(UserMixin, db.Model):
    id = db.Column(db.Integer, primary_key=True)
    ts = db.Column(db.DateTime, default=datetime.utcnow)
    cpu = db.Column(db.String)


class Test(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    ts = db.Column(db.DateTime, default=datetime.utcnow)
    cpu = db.Column(db.String)


<mask token>

<mask token>


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))
    about_me = db.Column(db.String(140))
    last_seen = db.Column(db.DateTime, default=datetime.utcnow)
    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_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(
            ) > 0

    def followed_posts(self):
        return Post.query.join(followers, followers.c.followed_id == Post.
            user_id).filter(followers.c.follower_id == self.id).order_by(Post
            .timestamp.desc())

    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 get_reset_password_token(self, expires_in=600):
        return jwt.encode({'reset_password': self.id, 'exp': time() +
            expires_in}, app.config['SECRET_KEY'], algorithm='HS256').decode(
            'utf-8')

    @staticmethod
    def verify_reset_password_token(token):
        try:
            id = jwt.decode(token, app.config['SECRET_KEY'], algorithms=[
                'HS256'])['reset_password']
        except:
            return
        return User.query.get(id)


class Post(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    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.body)


class Trajectory(UserMixin, db.Model):
    id = db.Column(db.Integer, primary_key=True)
    YYYY = db.Column(db.Integer)
    MM = db.Column(db.Integer)
    DD = db.Column(db.Integer)
    VENAU = db.Column(db.Float)
    SECLAT = db.Column(db.Float)
    SECLON = db.Column(db.Float)


class Cpu(UserMixin, db.Model):
    id = db.Column(db.Integer, primary_key=True)
    ts = db.Column(db.DateTime, default=datetime.utcnow)
    cpu = db.Column(db.String)


class Test(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    ts = db.Column(db.DateTime, default=datetime.utcnow)
    cpu = db.Column(db.String)


<mask token>

from app import\
	db,\
	app
from datetime import\
	datetime
from werkzeug.security import\
	generate_password_hash,\
	check_password_hash
from flask_login import\
	UserMixin
from app import\
	login
from hashlib import\
	md5
import jwt
from time import\
	time
followers=db.Table(
	'followers',
	db.Column('follower_id',db.Integer,db.ForeignKey('user.id')),
	db.Column('followed_id',db.Integer,db.ForeignKey('user.id'))
)
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))
	about_me=db.Column(db.String(140))
	last_seen=db.Column(db.DateTime,default=datetime.utcnow)
	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_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()>0
	def followed_posts(self):
		return Post.query.join(
			followers,(followers.c.followed_id==Post.user_id)
		).filter(
			followers.c.follower_id==self.id
		).order_by(
			Post.timestamp.desc()
		)
	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 get_reset_password_token(self, expires_in=600):
		return jwt.encode(
		    {'reset_password': self.id, 'exp': time() + expires_in},
		    app.config['SECRET_KEY'], algorithm='HS256').decode('utf-8')
	@staticmethod
	def verify_reset_password_token(token):
		try:
			id=jwt.decode(
				token,
				app.config['SECRET_KEY'],
				algorithms=['HS256'])['reset_password']
		except:
			return
		return User.query.get(id)
class Post(db.Model):
	id=db.Column(db.Integer,primary_key=True)
	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.body)
class Trajectory(UserMixin,db.Model):
	id=db.Column(db.Integer,primary_key=True)
	YYYY=db.Column(db.Integer)
	MM=db.Column(db.Integer)
	DD=db.Column(db.Integer)
	VENAU=db.Column(db.Float)
	SECLAT=db.Column(db.Float)
	SECLON=db.Column(db.Float)
class Cpu(UserMixin,db.Model):
	id=db.Column(db.Integer,primary_key=True)
	ts=db.Column(db.DateTime,default=datetime.utcnow)
	cpu=db.Column(db.String)
class Test(db.Model):
	id=db.Column(db.Integer,primary_key=True)
	ts=db.Column(db.DateTime,default=datetime.utcnow)
	cpu=db.Column(db.String)
@login.user_loader
def load_user(id):
	return User.query.get(int(id))
