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 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 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 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 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 user_create_new_tweet(username=None): user = User.query.filter_by(username=username).first() # st() user_id = user.id new_tweet = Tweet(user_id=user_id, text=request.form["tweet_text"]) db.session.add(new_tweet) db.session.commit() return redirect(f"/users/{username}/")
def new_tweet(): print("FORM DATA:", dict(request.form)) new_record = Tweet(tweet_id=request.form['tweets'], id=request.form['author_name']) db.session.add(new_record) db.session.commit() return redirect('/twitter')
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 create_tweet(): print('FORM DATA:', dict(request.form)) created_tweet = Tweet(content=request.form['content'], user_name=request.form['user_name']) db.session.add(created_tweet) db.session.commit() flash(f"Tweet by '{created_tweet.user_name}' created successfully!", "success") return redirect(f"/tweets")
def create_tweet(): print("FORM DATA:", dict(request.form)) # INSERT INTO users ... (store data in the database) new_tweet = Tweet(full_text=request.form["tweet"]) db.session.add(new_tweet) db.session.commit() return redirect("/tweets")
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 create_tweet(): print("FORM DATA:", dict(request.form)) # todo: store in database # INSERT INTO tweets ... new_tweet = Tweet(title=request.form["title"], author_id=request.form["author_name"]) db.session.add(new_tweet) db.session.commit() return redirect("/tweets")
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 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 create_tweets(): print("CREATING A NEW TWEET..") print("FORM DATA:", dict(request.form)) if "status" in request.form: tweet = request.form["status"] print(tweet) db.session.add(Tweet(status=tweet)) db.session.commit() return jsonify({"message": "CREATED OK", "tweet": tweet}) else: return jsonify({"message": "OOPS PLEASE SPECIFY A tweet!"})
def create_tweet(): print("FORM DATA:", dict(request.form)) new_tweet = Tweet(title=request.form["tweet text"], author_id=request.form["user"]) db.session.add(new_tweet) db.session.commit() return jsonify({ "message": "TWEET CREATED OK", "tweet": dict(request.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 add_to_database(): user=request.form['name'] tweets = client.user_timeline(user, tweet_mode="extended", count=200, exclude_replies=True, include_rts=False) userid = client.get_user(user).id try: db.session.add(User(name=user, id=userid)) db.session.commit() for tweet in tweets: interactions = tweet.retweet_count + tweet.favorite_count embedded = c.embed_sentence(tweet.full_text, model='twitter') db.session.add(Tweet(user_id=userid, status=tweet.full_text, id=tweet.id, embedding=embedded, interactions=interactions)) db.session.commit() except IntegrityError or InvalidRequestError: db.session.rollback() existing_ids = Tweet.query.filter(Tweet.user_id == userid).all() for tweet in tweets: if tweet.id not in existing_ids: interactions = tweet.retweet_count + tweet.favorite_count embedded = c.embed_sentence(tweet.full_text, model='twitter') db.session.add(Tweet(user_id=userid, status=tweet.full_text, id=tweet.id, embedding=embedded, interactions=interactions)) return jsonify({"message": "User and existing tweets added to database"})
def add_user(): print("FORM DATA:", dict(request.form)) # breakpoint() new_tweet = Tweet(text=request.form["text"], user=request.form["user"]) db.session.add(new_tweet) db.session.commit() return jsonify({ "message": "TWEET CREATED OK (TODO)", "text": dict(request.form) })
def create_tweet(): print("FORM DATA:", dict(request.form)) # Create a new Tweet model object new_tweet = Tweet(tweet=request.form["tweet_tweet"], handle=request.form["tweet_handle"]) # Add and commit to the database db.session.add(new_tweet) db.session.commit() # Display a flash meessage flash(f"Tweet '{new_tweet.tweet}' created successfully!", "success") return redirect("/tweets")
def create_tweet(): print("FORM DATA:", dict(request.form)) # INSERT INTO tweeta db ... add_tweet = Tweet(tweet=request.form["tweet"], tweeter_id=request.form["tweeter_name"]) db.session.add(add_tweet) db.session.commit() # to store in the database return jsonify({ "message": "Tweet added successfully!", "tweet": dict(request.form) })
def create_tweet(): print("FORM DATA:", dict(request.form)) # todo: store in database #return jsonify({ # "message": "BOOK CREATED OK (TODO)", # "book": dict(request.form) #}) new_tweet = Tweet(tweet_id=request.form["tweet_id"], tweet_content=request.form["tweet_content"]) print(new_tweet) db.session.add(new_tweet) db.session.commit() #flash(f"Book '{new_book.title}' created successfully!", "success") return redirect("/tweets")
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_tweet(): print("FORM DATA:", dict(request.form)) new_tweet = Tweet(title=request.form["tweet_title"], user_id=request.form["user_name"]) db.session.add(new_tweet) db.session.commit() return jsonify({ "message": "TWEET CREATED OK", "tweet": dict(request.form) }) flash(f"Tweet '{new_tweet.title}' Created successfully!", "info") return redirect(f"/tweets")
def create_tweet(): print("FORM DATA:", dict(request.form)) # todo: store in database # INSERT INTO tweets ... new_tweet = Tweet(tweet=request.form["tweet_content"], user_handle=request.form["user_handle"]) db.session.add(new_tweet) db.session.commit() # return jsonify({ # "message": "BOOK CREATED OK (TODO)", # "book": dict(request.form) # }) flash(f"Tweet '{new_tweet.tweet_content}' created successfully!", "success") return redirect(f"/tweets")
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")