def create_user():
print("FORM DATA", dict(request.form))
# return jsonify({
# "message": "it works!"
# })
new_user = User(
screen_name=request.form["screen_name"]
)
screen_name = request.form["screen_name"]
print(screen_name)
twitter_user = twitter_api_client.get_user(screen_name)
statuses = twitter_api_client.user_timeline(
screen_name, tweet_mode="extended", count=150)
print("STATUSES COUNT:", len(statuses))
# return jsonify({"user": user._json, "tweets": [s._json for s in statuses]})
# get existing user from the db or initialize a new one:
db_user = User.query.get(twitter_user.id) or User(id=twitter_user.id)
db_user.screen_name = twitter_user.screen_name
db_user.name = twitter_user.name
db_user.location = twitter_user.location
db_user.followers_count = twitter_user.followers_count
db.session.add(db_user)
db.session.commit()
# return "OK"
# breakpoint()
all_tweet_texts = [status.full_text for status in statuses]
embeddings = list(basilica_api_client().embed_sentences(
all_tweet_texts, model="twitter"))
print("NUMBER OF EMBEDDINGS", len(embeddings))
counter = 0
for status in statuses:
print(status.full_text)
print("----")
# get existing tweet from the db or initialize a new one:
db_tweet = Tweet.query.get(status.id) or Tweet(id=status.id)
db_tweet.user_id = status.author.id # or db_user.id
db_tweet.full_text = status.full_text
embedding = embeddings[counter]
print(len(embedding))
db_tweet.embedding = embedding
db.session.add(db_tweet)
counter += 1
db.session.commit()
# return "OK"
# tweets=db_tweets
return render_template("user.html", user=db_user, tweets=statuses)
def create_user():
new_user = User(screen_name=request.form["username"])
print("FORM DATA:", dict(request.form))
db.session.add(new_user)
db.session.commit()
# flash("asdf")
return redirect("/users")
def create_user():
print('FORM DATA:', dict(request.form))
created_user = User(name=request.form['name'])
db.session.add(created_user)
db.session.commit()
flash(f"User '{created_user.name}' created successfully!", "success")
return redirect("/users")
def fetch_user_data(screen_name):
print('FETCHING...', screen_name)
# fetch user info
user = twitter_api.get_user(screen_name)
#
# store user info in database
#
db_user = User.query.get(user.id) or User(id=user.id)
# $ x = 6 or 7
# x = 6
# $ y = None or 7
# y = 7
# If user input doesn't exist, create that user
db_user.screen_name = user.screen_name
db_user.name = user.name
db_user.location = user.location
db_user.followers_count = user.followers_count
db.session.add(db_user)
db.session.commit()
#
# fetch their tweets
#
statuses = twitter_api.user_timeline(screen_name,
tweet_mode="extended",
count=150)
print('STATUSES', len(statuses))
#
# fetch embedding for each tweet
#
tweet_texts = [status.full_text for status in statuses]
embeddings = list(
basilica_connection.embed_sentences(tweet_texts, model="twitter"))
# todo: prefer to make a single request to basilica with all the tweet texts, instead of
# a request per tweet
print('EMBEDDINGS', len(embeddings))
#
# store tweets in database (w/ embeddings)
#
for index, status in enumerate(statuses):
print(status.full_text)
print("----")
db_tweet = Tweet.query.get(status.id) or Tweet(id=status.id)
db_tweet.user_id = status.author.id # or db_user.id
db_tweet.full_text = status.full_text
embedding = embeddings[index]
print(len(embedding))
db_tweet.embedding = embedding
db.session.add(db_tweet)
db.session.commit()
return f'FETCHED {screen_name} OK'
def fetch_user_data(screen_name):
print("FETCHING...", screen_name)
#
# fetch user info
#
try:
user = twitter_api.get_user(screen_name)
except tweepy.error.TweepError:
flash(f"User '{screen_name}' does not exist!", "dark")
return redirect("/users")
#
# store user info in database
#
db_user = User.query.get(user.id) or User(id=user.id)
db_user.screen_name = user.screen_name
db_user.name = user.name
db_user.location = user.location
db_user.followers_count = user.followers_count
db.session.add(db_user)
db.session.commit()
#
# fetch their tweets
#
# statuses = twitter_api.user_timeline(screen_name, tweet_mode="extended", count=35, exclude_replies=True, include_rts=False)
statuses = twitter_api.user_timeline(screen_name,
tweet_mode="extended",
count=150)
print("STATUSES", len(statuses))
#
# fetch embedding for each tweet
#
tweet_texts = [status.full_text for status in statuses]
embeddings = list(
basilica_connection.embed_sentences(tweet_texts, model="twitter"))
print("EMBEDDINGS", len(embeddings))
#
# store tweets in database (w/ embeddings)
#
for index, status in enumerate(statuses):
print(status.full_text)
print("----")
# get existing tweet from the db or initialize a new one:
db_tweet = Tweet.query.get(status.id) or Tweet(id=status.id)
db_tweet.user_id = status.author.id
db_tweet.full_text = status.full_text
embedding = embeddings[index]
print(len(embedding))
db_tweet.embedding = embedding
db.session.add(db_tweet)
db.session.commit()
flash(f"User '{screen_name}' added successfully!", "dark")
return redirect("/users")
def gen_tweets(q='#lambdaschool', count=100, ang='en', since='2019-10-21'):
for tweet in tweepy.Cursor(TWITTER.search,
q=q,
count=count,
ang=ang,
since=since,
tweet_mode='extended').items():
created_tweet = Tweet(id=tweet.id,
timestamp=tweet.created_at,
content=tweet.full_text,
user_id=tweet.user.id,
embeddings=connection.embed_sentence(
tweet.full_text, model='twitter'))
referenced_user = User(id=tweet.user.id, name=tweet.user.screen_name)
try:
db.session.add(created_tweet)
db.session.add(referenced_user)
db.session.commit()
except exc.IntegrityError:
try:
db.session.rollback()
db.session.add(created_tweet)
db.session.commit()
except exc.IntegrityError:
db.session.rollback()
db.session.commit()
time.sleep(2)
def register():
"""
Функция регистрации пользователя
:return: Страницы Login или Register
"""
if request.method == "POST":
# Достаем из формы данные пользователя
username = request.form["FirstName"]
lastname = request.form["LastName"]
email = request.form["Email"]
password = request.form["Password"]
repeat_password = request.form["RepeatPassword"]
# Проверяем был ли зарегистрирован пользователь с таким
# же адресом электронной почты
row = db_session.query(User).filter(User.email == email).all()
# Если пользователя с таким же адресом Email нет, то регистрируем его
if not row:
# Проверяем пароль
if password != repeat_password:
flash("Ошибка при вводе паролей")
else:
# Шифруем пароль
h_password = hash_password(password)
user = User(username, lastname, email, datetime.now(), h_password)
db_session.add(user)
db_session.commit()
# Отправляем пользователя на страницу авторизации
return redirect("login")
else:
# Если пользователь с таким же адресом существует, то выдаем ошибку
flash("Такой пользователь уже зарегистрирован. Используйте другой адрес электронной почты.")
return redirect("register")
return render_template("register.html")
def get_tweets(username):
user = TWITTER.get_user(username)
statuses = TWITTER.user_timeline(username,
tweet_mode="extended",
count=150)
tmp = []
referenced_user = User(id=user.id, name=user.screen_name)
try:
db.session.add(referenced_user)
db.session.commit()
except exc.IntegrityError:
db.session.rollback()
db.session.commit()
for tweet in statuses:
created_tweet = Tweet(id=tweet.id,
timestamp=tweet.created_at,
content=tweet.full_text,
user_id=tweet.user.id,
embeddings=connection.embed_sentence(
tweet.full_text, model='twitter'))
try:
db.session.add(created_tweet)
db.session.commit()
except exc.IntegrityError:
db.session.rollback()
db.session.commit()
for tweet in statuses:
tmp.append(tweet.full_text)
username = user.screen_name
followers = user.followers_count
return username, followers, tmp
def store_twitter_user_data(screen_name):
api = twitter_api_client()
twitter_user = api.get_user(screen_name)
statuses = api.user_timeline(screen_name, tweet_mode="extended", count=150)
db_user = User.query.get(twitter_user.id) or User(id=twitter_user.id)
db_user.screen_name = twitter_user.screen_name
db_user.name = twitter_user.name
db_user.location = twitter_user.location
db_user.followers_count = twitter_user.followers_count
db.session.add(db_user)
db.session.commit()
print("STATUS COUNT:", len(statuses))
basilica_api = basilica_api_client()
all_tweet_texts = [status.full_text for status in statuses]
embeddings = list(
basilica_api.embed_sentences(all_tweet_texts, model="twitter"))
print("NUMBER OF EMBEDDINGS", len(embeddings))
counter = 0
for status in statuses:
print(status.full_text)
print("----")
db_tweet = Tweet.query.get(status.id) or Tweet(id=status.id)
db_tweet.user_id = status.author.id
db_tweet.full_text = status.full_text
embedding = embeddings[counter]
print(len(embedding))
db_tweet.embedding = embedding
db.session.add(db_tweet)
counter += 1
db.session.commit()
return db_user, statuses
def create_user():
print("CREATING A NEW USER...")
print("FORM DATA:", dict(request.form))
name = request.form["name"]
if len(name) > 0:
try:
user_obj = client.get_user(name)
db.session.add(User(name=name, id=user_obj.id))
db.session.commit()
tweets = client.user_timeline(name, tweet_mode="extended")
friends = client.friends_ids(name)
for tweet in tweets:
interactions = tweet.retweet_count + tweet.favorite_count
db.session.add(Tweet(user_id=user_obj.id, status=tweet.full_text, id=tweet.id, interactions=interactions))
db.session.commit()
for friend in friends:
db.session.add(Friends(user_id=friend, friend_of_id=user_obj.id))
db.session.commit()
except TweepError:
return render_template('error_new_user.html')
print(jsonify({"message": "CREATED OK", "name": name}))
return render_template('new_user_created.html')
else:
print(jsonify({"message": "OOPS PLEASE SPECIFY A NAME!"}))
return render_template('error_new_user.html')
def add_or_update_user(username):
try:
twitter_user = client.get_user(username)
db_user = (User.query.get(twitter_user.id)
or User(id=twitter_user.id, name=username))
db.session.add(db_user)
tweets = twitter_user.timeline(count=100,
exclude_replies=True,
include_rts=False,
tweet_mode='extended',
since_id=db_user.newest_tweet.id)
if tweets:
db_user.newest_tweet_id = tweets[0].id
for tweet in tweets:
embedding = basilica_client.embed_sentence(tweet.full_text,
model='twittr')
db_tweet = Tweet(id=tweet.id,
text=tweet.full_text[:300],
embedding=embedding)
db_user.tweets.append(db_tweet)
db.session.add(db_tweet)
except Exception as e:
print('Error processing {}: {}'.format(username, e))
raise e
else:
db.session.commit()
def register():
if current_user.is_authenticated:
return redirect(url_for('index'))
form = RegistrationForm()
if form.validate_on_submit():
user = User(username=form.username.data,
email=form.email.data,
confirmed=False)
user.set_password(form.password.data)
token = generate_confirmation_token(user.email)
confirm_url = url_for('confirm_email', token=token, _external=True)
message_body = user.email + ';' + confirm_url
q = get_welcome_queue()
q.basic_publish(exchange='',
routing_key='email-queue',
body=message_body,
properties=pika.BasicProperties(
delivery_mode=_DELIVERY_MODE_PERSISTENT))
flash('A confirmation email has been sent via email.')
db.session.add(user)
db.session.commit()
return redirect(url_for('unconfirmed'))
return render_template('register.html', title='Register', form=form)
def fetch_user_data(screen_name):
print("Fetching...", screen_name)
#
# fetch user info
#
user = twitter_api.get_user(screen_name)
#
# Store users info in database
#
db_user = User.query.get(user.id) or User(id=user.id)
db_user.screen_name = user.screen_name
db_user.name = user.name
db_user.location = user.location
db_user.followers_count = user.followers_count
db.session.add(db_user)
db.session.commit()
#
# fetch user tweets
#
statuses = twitter_api.user_timeline(screen_name,
tweet_mode="extended",
count=150,
include_rts=False)
print("Statuses ", len(statuses))
#
# fetch embedding for each tweet
#
tweet_texts = [status.full_text for status in statuses]
embeddings = list(
basilica_connection.embed_sentences(tweet_texts, model="twitter"))
print("Embeddings ", embeddings)
#
# Store tweets in database (w/ embeddings)
#
for index, status in enumerate(statuses):
print(status.full_text)
print("----")
db_tweet = Tweet.query.get(status.id) or Tweet(id=status.id)
db_tweet.user_id = status.author.id
db_tweet.full_text = status.full_text
embedding = embeddings[index]
print(len(embedding))
db_tweet.embedding = embedding
db.session.add(db_tweet)
db.session.commit()
# TODO: store tweets in database (w/ embeddings)
return f"Fetched {screen_name} OK"
# return jsonify({"user": user._json, "num_tweets": len(statuses)})
def seed_db():
name = 'admin'
password = '******'
email = '*****@*****.**'
u = User(username=name, email=email, admin=1)
u.set_password(password)
db.session.add(u)
db.session.commit()
def fetch_user(screen_name=None):
print(screen_name)
# breakpoint()
# FETCH DATA FROM TWITTER API
twitter_user = twitter_api_client.get_user(screen_name)
breakpoint()
# tweets = twitter_api_client.user_timeline(screen_name, tweet_mode="extended", count=150, exclude_replies=True, include_rts=False)
# print("TWEETS COUNT:", len(tweets))
#return jsonify({"user": user._json, "tweets": [s._json for s in statuses]})
# STORE TWITTER DATA IN DB
# get existing user from the db or initialize a new one:
db_user = User.query.get(twitter_user.id) or User(id=twitter_user.id)
db_user.screen_name = twitter_user.screen_name
db_user.name = twitter_user.name
db_user.location = twitter_user.location
db_user.followers_count = twitter_user.followers_count
db.session.add(db_user)
db.session.commit()
#return "OK"
#breakpoint()
# FETCH TWEETS
tweets = twitter_api_client.user_timeline(screen_name, tweet_mode="extended", count=150, exclude_replies=True, include_rts=False)
print("TWEETS COUNT:", len(tweets))
# basilica_api = basilica_api_client()
all_tweet_texts = [status.full_text for status in tweets]
embeddings = list(basilica_api_client.embed_sentences(all_tweet_texts, model="twitter"))
print("NUMBER OF EMBEDDINGS", len(embeddings))
# # TODO: explore using the zip() function maybe...
# counter = 0
for index, status in enumerate(tweets):
print(index)
print(status.full_text)
print("----")
# embedding = basilica_api_client.embed_sentence(status.full_text, model="twitter") # todo: prefer to make a single request to basilica with all the tweet texts, instead of a request per tweet
# print(len(embedding))
embedding = embeddings[index]
#print(dir(status))
# get existing tweet from the db or initialize a new one:
db_tweet = Tweet.query.get(status.id) or Tweet(id=status.id)
db_tweet.user_id = status.author.id # or db_user.id
db_tweet.full_text = status.full_text
db_tweet.embedding = embedding
db.session.add(db_tweet)
# counter+=1
db.session.commit()
# return "OK"
print('path A')
return render_template("user.html", user=db_user, tweets=tweets) # tweets=db_tweets
def fetch_user_data(screen_name=None):
print(screen_name)
api = api_client()
twitter_user = api.get_user(screen_name)
statuses = api.user_timeline(screen_name,
tweet_mode="extended",
count=300,
exclude_replies=False,
include_rts=True)
print("STATUSES COUNT:", len(statuses))
#new_book = Book(title=request.form["book_title"], author_id=request.form["author_name"])
#db.session.add(new_book)
#db.session.commit()
#
# STORE USER
#
# get existing user from the db or initialize a new one:
db_user = User.query.get(twitter_user.id) or User(id=twitter_user.id)
db_user.screen_name = twitter_user.screen_name
db_user.name = twitter_user.name
db_user.location = twitter_user.location
db_user.followers_count = twitter_user.followers_count
db.session.add(db_user)
db.session.commit()
#breakpoint()
#
# STORE TWEETS
#
all_tweet_texts = [status.full_text for status in statuses]
embeddings = list(
basilica_connection.embed_sentences(all_tweet_texts, model="twitter"))
print("NUMBER OF EMBEDDINGS", len(embeddings))
# TODO: explore using the zip() function maybe...
counter = 0
for status in statuses:
print(status.full_text)
print("----")
#print(dir(status))
# get existing tweet from the db or initialize a new one:
db_tweet = Tweet.query.get(status.id) or Tweet(id=status.id)
db_tweet.user_id = status.author.id # or db_user.id
db_tweet.full_text = status.full_text
#embedding = basilica_connection.embed_sentence(status.full_text, model="twitter") # todo: prefer to make a single request to basilica with all the tweet texts, instead of a request per tweet
embedding = embeddings[counter]
print(len(embedding))
db_tweet.embedding = embedding
db.session.add(db_tweet)
counter += 1
db.session.commit()
return "OK"
def fetch_user_data(screen_name):
print("FETCHING...", screen_name)
#
# fetch user info
#
user = twitter_api.get_user(screen_name)
#
# store user info in database
#
db_user = User.query.get(user.id) or User(id=user.id)
db_user.screen_name = user.screen_name
db_user.name = user.name
db_user.location = user.location
db_user.followers_count = user.followers_count
db.session.add(db_user)
db.session.commit()
#
# fetch their tweets
#
statuses = twitter_api.user_timeline(screen_name,
tweet_mode="extended",
count=150)
print("STATUSES", len(statuses))
#
# fetch embedding for each tweet
#
tweet_texts = [status.full_text for status in statuses]
embeddings = list(
basilica_connection.embed_sentences(tweet_texts, model="twitter"))
print("EMBEDDINGS", len(embeddings))
#
# store tweets in database (w/ embeddings)
#
for index, status in enumerate(statuses):
print(status.full_text)
print("----")
db_tweet = Tweet.query.get(status.id) or Tweet(id=status.id)
db_tweet.user_id = status.author.id
db_tweet.full_text = status.full_text
embedding = embeddings[index]
print(len(embedding))
db_tweet.embedding = embedding
db.session.add(db_tweet)
db.session.commit()
return f"FETCHED {screen_name} OK"
def login():
if request.method == 'POST':
users = db.users
existing_user = users.find_one({'username': request.form['username']})
if existing_user:
if check_password_hash(existing_user['password'], request.form['password']):
login_user(User(existing_user))
session['username'] = request.form['username']
return redirect(url_for('user.index'))
return render_template('login.html')
def fetch_user(screen_name=None):
print(screen_name)
# FETCHING DATA FROM TWITTER API
twitter_user = twitter_api_client.get_user(screen_name)
# STORING TWITTER DATA IN THE DATABASE
# get existing user from the db OR initialize a new one:
db_user = User.query.get(twitter_user.id) or User(id=twitter_user.id)
db_user.screen_name = twitter_user.screen_name
db_user.name = twitter_user.name
db_user.location = twitter_user.location
db_user.followers_count = twitter_user.followers_count
db.session.add(db_user)
db.session.commit()
# return "OK"
# breakpoint()
# FETCH TWEETS
tweets = twitter_api_client.user_timeline(screen_name,
tweet_mode="extended",
count=150)
print("TWEETS COUNT:", len(tweets))
# STORING TWITTER DATA IN THE DATABASE
all_tweet_texts = [status.full_text for status in tweets]
embeddings = list(
basilica_api_client.embed_sentences(all_tweet_texts, model="twitter"))
print("NUMBER OF EMBEDDINGS", len(embeddings))
for index, status in enumerate(tweets):
print(index)
print(status.full_text)
print("----")
# embedding = basilica_api_client.embed_sentence(status.full_text,
# model="twitter")
# todo: prefer to make a single request to basilica with all the tweet
# texts, instead of a request per tweet
# print(len(embedding))
embedding = embeddings[index]
# get existing tweet from the db or initialize a new one:
db_tweet = Tweet.query.get(status.id) or Tweet(id=status.id)
db_tweet.user_id = status.author.id # or db_user.id
db_tweet.full_text = status.full_text
db_tweet.embedding = embedding
db.session.add(db_tweet)
db.session.commit()
return "OK"
def create_user():
print("FORM DATA:", dict(request.form))
new_user = User(user_name=request.form["user_name"])
db.session.add(new_user)
db.session.commit()
return jsonify({
"message": "USER CREATED OK",
"user": dict(request.form)
})
def fetch_user_data(screen_name):
print("INFO: fetching twitter for inforation for: ", screen_name)
# Fetch user info from the Twitter API
user = twitter_api.get_user(screen_name)
# Grab a user object from the database or create new
db_user = User.query.get(user.id) or User(id=user.id)
# Update user object data
db_user.screen_name = user.screen_name
db_user.name = user.name
db_user.location = user.location
db_user.followers_count = user.followers_count
# Update the database
db.session.add(db_user)
db.session.commit()
print("INFO: update user information in the db for: ", screen_name)
# Fetch the user's tweets
statuses = twitter_api.user_timeline(screen_name,
tweet_mode="extended",
count=10)
print("INFO: just recevied Twitter statuses number = ", len(statuses))
# Fetch embeddings for each tweet
tweet_texts = [status.full_text for status in statuses]
embeddings = list(
basilica_connection.embed_sentences(tweet_texts, model="twitter"))
print("INFO: just received tweet embeddings number = ", len(embeddings))
# store tweets and associated embeddings in the database
ctr = 0
print("INFO: just before look")
for idx, status in enumerate(statuses):
db_tweet = Tweet.query.get(status.id) or Tweet(id=status.id)
db_tweet.user_id = status.author.id
db_tweet.full_text = status.full_text
embedding = embeddings[idx]
db_tweet.embedding = embedding
db.session.add(db_tweet)
ctr = ctr + 1
print("INFO: storing tweets and embeddings in the database number = ", ctr)
db.session.commit()
flash(
f'Just stored tweet and embedding information into the database! Number of updates: {ctr}',
"success")
return redirect("/call_twitter")
def register():
if current_user.is_authenticated:
return redirect(url_for('index'))
form = RegistrationForm()
if form.validate_on_submit():
user = User(username=form.username.data, email=form.email.data)
user.set_password(form.password.data)
db.session.add(user)
db.session.commit()
flash('Congratulations, you are now a registered user!')
return redirect(url_for('login'))
return render_template('register.html', title='Register', form=form)
def get_user(screen_name=None):
print(screen_name)
api = twitter_api()
twitter_user = api.get_user(screen_name)
statuses = api.user_timeline(screen_name,
tweet_mode="extended",
count=150,
exclude_replies=True,
include_rts=False)
print("STATUSES COUNT:", len(statuses))
#return jsonify({"user": user._json, "tweets": [s._json for s in statuses]})
# get existing user from the db or initialize a new one:
db_user = User.query.get(twitter_user.id) or User(id=twitter_user.id)
db_user.screen_name = twitter_user.screen_name
db_user.name = twitter_user.name
db_user.location = twitter_user.location
db_user.followers_count = twitter_user.followers_count
db.session.add(db_user)
db.session.commit()
#return "OK"
#breakpoint()
basilica_api = basilica_api_client()
all_tweet_texts = [status.full_text for status in statuses]
embeddings = list(
basilica_api.embed_sentences(all_tweet_texts, model="twitter"))
print("NUMBER OF EMBEDDINGS", len(embeddings))
# TODO: explore using the zip() function maybe...
counter = 0
for status in statuses:
print(status.full_text)
print("----")
#print(dir(status))
# get existing tweet from the db or initialize a new one:
db_tweet = Tweet.query.get(status.id) or Tweet(id=status.id)
db_tweet.user_id = status.author.id # or db_user.id
db_tweet.full_text = status.full_text
#embedding = basilica_client.embed_sentence(status.full_text, model="twitter") # todo: prefer to make a single request to basilica with all the tweet texts, instead of a request per tweet
embedding = embeddings[counter]
print(len(embedding))
db_tweet.embedding = embedding
db.session.add(db_tweet)
counter += 1
db.session.commit()
#breakpoint()
#return "OK"
return render_template("user.html", user=db_user,
tweets=statuses) # tweets=db_tweets
def create_users():
print("CREATING A NEW USER...")
print("FORM DATA:", dict(request.form))
if "name" in request.form:
name = request.form["name"]
print(name)
db.session.add(User(name=name))
db.session.commit()
return jsonify({"message": "CREATED OK", "name": name})
else:
return jsonify({"message": "OOPS PLEASE SPECIFY A NAME!"})
def create_user():
print("CREATING A NEW USER...")
print("FORM DATA:", dict(request.form))
# todo: create a new user
# return jsonify({"message": "CREATED OK (TODO)"})
if "username" in dict(request.form):
name = request.form["username"]
country = request.form["country"]
db.session.add(User(name=name))
# db.session.add(User(country=country))
db.session.commit()
return jsonify({"message": "CREATED OK", "name": name})
else:
return jsonify({"message": "OOPS PLEASE SPECIFY A NAME!"})
def create_user():
print("FORM DATA:", dict(request.form))
# todo: store in database
print(request.form["screen_name"])
api = api_client()
twitter_user = api.get_user(request.form["screen_name"])
statuses = api.user_timeline(
request.form["screen_name"], tweet_mode="extended",
count=150) #, exclude_replies=True, include_rts=False)
print("STATUSES COUNT:", len(statuses))
# STORE USER
# get existing user from the db or initialize a new one:
db_user = User.query.get(twitter_user.id) or User(
id=twitter_user.id) #if not in DB add to db.
db_user.screen_name = twitter_user.screen_name
db_user.name = twitter_user.name
db_user.location = twitter_user.location
db_user.followers_count = twitter_user.followers_count
db.session.add(db_user)
db.session.commit()
#breakpoint()
# STORE TWEETS
all_tweet_texts = [status.full_text for status in statuses]
embeddings = list(
basilica_connection.embed_sentences(all_tweet_texts, model="twitter"))
print("NUMBER OF EMBEDDINGS", len(embeddings))
# TODO: explore using the zip() function maybe...
counter = 0
for status in statuses:
print(status.full_text)
print("----")
#print(dir(status))
# get existing tweet from the db or initialize a new one:
db_tweet = Tweet.query.get(status.id) or Tweet(id=status.id)
db_tweet.user_id = status.author.id # or db_user.id
db_tweet.full_text = status.full_text
#embedding = basilica_client.embed_sentence(status.full_text, model="twitter") # todo: prefer to make a single request to basilica with all the tweet texts, instead of a request per tweet
embedding = embeddings[counter]
print(len(embedding))
db_tweet.embedding = embedding
db.session.add(db_tweet)
counter += 1
db.session.commit()
return redirect(f"/user_list")
def register():
if current_user.is_authenticated:
return redirect(url_for('index'))
form = RegistrationForm()
if form.validate_on_submit():
user = User(login=form.username.data, email=form.email.data)
user.set_password(form.password.data)
USM.insert(user)
token = generate_confirmation_token(user.email)
confirm_url = url_for('confirm_email', token=token, _external=True)
email_sender.send(json.dumps({"email": user.email, "token":confirm_url}))
flash('To complete your registration, confirm your email')
return redirect(url_for('login'))
return render_template('register.html', title='Register', form=form)
def fetch_user(screen_name=None):
print(screen_name)
api = twitter_api()
twitter_user = api.get_user(screen_name)
# Get user from database if exists, if not initialaize new one:
db_user = User.query.get(twitter_user.id) or User(id=twitter_user.id)
db_user.screen_name = twitter_user.screen_name
db_user.name = twitter_user.name
db_user.location = twitter_user.location
db_user.followers_count = twitter_user.followers_count
# store user in a database:
db.session.add(db_user)
db.session.commit()
# Get tweets:
basilica_api = basilica_api_client()
tweets = api.user_timeline(screen_name, tweet_mode="extended", count=150)
# exclude_replies=True, include_rts=False)
all_tweet_texts = [status.full_text for status in tweets]
embeddings = list(
basilica_api.embed_sentences(all_tweet_texts, model="twitter"))
print("Number Of Embeddings", len(embeddings))
for index, status in enumerate(tweets):
print(index)
print(status.full_text)
print("----")
embedding = embeddings[index]
# get existing tweet from the db or initialize a new one:
db_tweet = Tweet.query.get(status.id) or Tweet(id=status.id)
db_tweet.user_id = status.author.id # or db_user.id
db_tweet.full_text = status.full_text
# embedding = embeddings[counter]
print(len(embeddings))
db_tweet.embedding = embedding
db.session.add(db_tweet)
db.session.commit()
return "OK"
def store_twitter_user_data(screen_name):
api = twitter_api_client()
twitter_user = api.get_user(screen_name)
statuses = api.user_timeline(screen_name,
tweet_mode="extended",
count=200,
exclude_replies=True,
include_rts=False)
# return jsonify({"user": user._json, "tweets": [s._json for s in statuses]})
# store users
db_user = User.query.get(twitter_user.id) or User(id=twitter_user.id)
db_user.screen_name = twitter_user.screen_name
db_user.name = twitter_user.name
db_user.location = twitter_user.location
db_user.followers_count = twitter_user.followers_count
db.session.add(db_user)
db.session.commit()
#return "OKAY"
# store basilica embedded tweets
print("STATUS COUNT:", len(statuses))
basilica_api = basilica_api_client()
all_tweet_texts = [status.full_text for status in statuses]
embeddings = list(
basilica_api.embed_sentences(all_tweet_texts, model="twitter"))
print("NUMBER OF EMBEDDINGS", len(embeddings))
# TODO: explore using the zip() function maybe...
counter = 0
for status in statuses:
print(status.full_text)
print("----")
#print(dir(status))
# Find or create database tweet:
db_tweet = Tweet.query.get(status.id) or Tweet(id=status.id)
db_tweet.user_id = status.author.id # or db_user.id
db_tweet.full_text = status.full_text
#embedding = basilica_client.embed_sentence(status.full_text, model="twitter") # todo: prefer to make a single request to basilica with all the tweet texts, instead of a request per tweet
embedding = embeddings[counter]
print(len(embedding))
db_tweet.embedding = embedding
db.session.add(db_tweet)
counter += 1
db.session.commit()
return db_user, statuses
def get_user(screen_name=None):
print(screen_name)
twitter_user = twitter_api_client.get_user(screen_name)
# breakpoint()
# find or create database user:
db_user = User.query.get(twitter_user.id) or User(id=twitter_user.id)
db_user.screen_name = twitter_user.screen_name
db_user.name = twitter_user.name
db_user.location = twitter_user.location
db_user.followers_count = twitter_user.followers_count
db.session.add(db_user)
db.session.commit()
return render_template("user.html", user=db_user)