def index(request):
context = dict()
if request.method == 'POST':
if 'delete_tweet' in request.POST:
_id = request.GET.get('id', None)
Tweet.objects.filter(id=_id).delete()
messages.success(request, "Tweet successfully deleted")
return redirect('index')
form = TweetForm(request.POST)
if form.is_valid():
new_tweet = Tweet(username=request.user,
tweet=request.POST['tweet'])
try:
new_tweet.full_clean()
new_tweet.save()
except ValidationError as e:
context['error'] = e.message_dict['tweet'][0]
else:
messages.success(request, "Tweet Created!")
return redirect('index')
else:
form = TweetForm()
context['form'] = form
context['tweets'] = Tweet.objects.filter(
username=request.user).order_by('-post_date')
return render(request, 'authenticated_user_feed.html', context)
def create_tweet(author, content, original_tweet):
new_tweet = Tweet(
author=author,
content=content,
original_tweet=original_tweet,
)
new_tweet.save()
return new_tweet
def process(request):
tweet = request.POST["tweet"]
t = Tweet(
text=tweet,
p_date=timezone.now(),
user=request.user
)
t.save()
return HttpResponseRedirect(reverse('index'))
def tweet(request):
f = TweetForm(request.POST)
if f.is_valid():
t = Tweet()
t.user = request.user
t.text = f.cleaned_data["text"]
t.published_on = datetime.datetime.today()
t.save()
return HttpResponseRedirect(reverse('twitter:home'))
def test_string_representation(self):
twitter_account = TwitterAccount(name='Peter')
tweet = Tweet(
content='Erster Tweet, #cool!',
created_at=datetime(2012, 12, 21, 19, 9, 0),
account=twitter_account,
)
self.assertEqual(
str(tweet), 'Peter at 2012-12-21 19:09:00 - Erster Tweet, #cool!')
def tweet(request):
if request.user.is_authenticated():
t = Tweet()
t.user = request.user
t.text = request.POST["text"]
t.published_on = datetime.datetime.today()
t.save()
return HttpResponseRedirect(reverse('twitter:home'))
else:
return HttpResponseRedirect(reverse('twitter:login'))
def home(request):
if request.method == "POST":
canTweet = True
error_tweet_30 = ""
if request.session.has_key("time_of_last_tweet"):
old_time = datetime.datetime.strptime(
request.session["time_of_last_tweet"], "%d %m %Y %H:%M:%S")
delta = datetime.datetime.today() - old_time
print datetime.datetime.today()
print old_time
print delta
print delta.total_seconds()
print delta.seconds
if delta.total_seconds() < 30:
canTweet = False
error_tweet_30 = "You have tweeted " + str(int(delta.total_seconds())) + \
" seconds ago."
if canTweet:
f = TweetForm(request.POST)
if f.is_valid():
t = Tweet()
t.user = request.user
t.text = f.cleaned_data["text"]
d = datetime.datetime.today()
t.published_on = d
t.save()
request.session["time_of_last_tweet"] = d.strftime(
"%d %m %Y %H:%M:%S")
return HttpResponseRedirect(reverse("twitter:home"))
else:
tweets = Tweet.objects.order_by("-published_on")[:5]
return render(request, 'twitter/home.html', {
"tweets": tweets,
"user": request.user,
"f": f
})
else:
f = TweetForm()
tweets = Tweet.objects.order_by("-published_on")[:5]
return render(
request, 'twitter/home.html', {
"tweets": tweets,
"user": request.user,
"f": f,
"er30": error_tweet_30
})
else:
f = TweetForm()
tweets = Tweet.objects.order_by("-published_on")[:5]
return render(request, 'twitter/home.html', {
"tweets": tweets,
"user": request.user,
"f": f
})
def setUp(self):
self.users = {
'author': User.objects.create(username='******'),
'user1': User.objects.create(username='******'),
'user2': User.objects.create(username='******'),
'user3': User.objects.create(username='******'),
}
self.tweet = Tweet(author=self.users['author'],
tweet_text='aaa',
pub_date=timezone.now())
self.tweet.save()
def new_tweet(request):
current_user = request.user
tweet_title = request.data.get('tweet_title')
tweet_text = request.data.get('tweet_text')
if tweet_text == '' or tweet_text == '':
return Response(status=status.HTTP_400_BAD_REQUEST)
tweet = Tweet(author=current_user,
tweet_title=tweet_title,
tweet_text=tweet_text,
pub_date=timezone.now())
tweet.save()
return Response(status=status.HTTP_201_CREATED)
def create_tweet():
print("FORM DATA:", dict(request.form))
new_tweet = Tweet(content=request.form["content"],
user=request.form["User_name"])
db.session.add(new_tweet)
db.session.commit()
return jsonify({
"message": "Successfully Created (TODO)",
"book": dict(request.form)
})
def run():
# create topic
topic_example = TwTopic()
topic_example.title = "migration"
topic, created = TwTopic.objects.get_or_create(topic_example.__dict__)
# create query string with well known migration organisations and their twitter accounts
settings_dir = os.path.dirname(__file__)
project_root = Path(os.path.dirname(settings_dir)).absolute()
twitter_addresses_yaml = Path.joinpath(project_root, "twitter\\twitter_addresses.yaml")
with open(twitter_addresses_yaml) as f:
# use safe_load instead load
data_map = yaml.safe_load(f)
class TwitterAddresses:
def __init__(self, entries):
self.__dict__.update(entries)
addresses = TwitterAddresses(data_map)
pp = pprint.PrettyPrinter(indent=4)
# query_string = ""
# for (institution in addresses.institutions):
# query_string+= institution.twitter_account
# institutions = list(map(lambda x: list(x.values())[0], addresses.institutions))
institutions = addresses.institutions
twitter_accounts = map(lambda x: x.get('institution').get('twitter_account').replace("@", ""), institutions)
twitter_accounts_query_1 = map(lambda x: "(from:{}) OR ".format(x), twitter_accounts)
twitter_accounts_query_2 = reduce(lambda x, y: x + y, twitter_accounts_query_1)
twitter_accounts_query_2 += "#immigration lang:en"
pp.pprint(twitter_accounts_query_2)
params = {'query': '{}'.format(twitter_accounts_query_2), 'max_results': '500'}
search_url = "https://api.twitter.com/2/tweets/search/all"
connector = TwitterConnector(1)
json_result = connector.get_from_twitter(search_url, params, True)
# print(json.dumps(json_result, indent=4, sort_keys=True))
twitter_data: list = json_result.get("data")
for tweet_raw in twitter_data:
try:
tweet = Tweet()
tweet.topic = topic
tweet.query_string = twitter_accounts_query_2
tweet.text = tweet_raw.get("text")
tweet.twitter_id = tweet_raw.get("id")
tweet.save()
except IntegrityError:
pass
def postTweet(request):
if request.method == 'POST':
form = tweetForm(request.POST)
if form.is_valid():
username = form.cleaned_data['username']
textarea = form.cleaned_data['textarea']
p = Tweet(userName=username, content=textarea)
p.save()
return render_to_response('submit.html', {'user': username},
context_instance=RequestContext(request))
form = tweetForm()
return render_to_response('newTweet.html', {'form': form},
context_instance=RequestContext(request))
def tweet_view(request, slug):
tweet = Tweet.objects.get(slug=slug)
if request.method == 'POST':
text = request.POST.get('tweet_comment')
new_tweet = Tweet(author=request.user, body=text, replying_tweet=tweet)
new_tweet.save()
comments = Tweet.objects.filter(replying_tweet=tweet)
context = {
'tweet': tweet,
'comments': comments,
'username': request.user.get_username()
}
return render(request, 'twitter/tweet.html', context)
def envoyer_tweet(request):
if request.user.is_authenticated():
login= UserProfil.objects.get(pk = request.user.pk)
if request == "POST":
tweet_form = TweetForm(request.POST)
if tweet_form.is_valide():
tweet = Tweet()
tweet.message = tweet_form.cleaned_data['message']
tweet.date = datetime.date.today()
tweet.user = login
tweet.save()
return redirect(user_profil)
else:
tweet_form = TweetForm()
tweets = Tweet.objects.all().order_by('date')
contexte = {'tweets': tweets, 'tweet_form' : tweet_form}
return render(request,'bienvenue.html', contexte)
def home(request):
if request.method == "POST":
f = TweetForm(request.POST)
if f.is_valid():
t = Tweet()
t.user = request.user
t.text = f.cleaned_data["text"]
t.published_on = datetime.datetime.today()
t.save()
else:
tweets = Tweet.objects.order_by("-published_on")[:5]
return render(request, 'twitter/home.html', {
"tweets": tweets,
"f": f
})
else:
f = TweetForm()
tweets = Tweet.objects.order_by("-published_on")[:5]
return render(request, 'twitter/home.html', {"tweets": tweets, "f": f})
def run():
# create topic
topic_example = TwTopic()
topic_example.title = "random"
topic, created = TwTopic.objects.get_or_create(topic_example.__dict__)
count = 500
connector = TwitterConnector(1)
random_stream_url = "https://api.twitter.com/2/tweets/sample/stream"
headers = connector.create_headers()
params = {'tweet.fields': 'lang'}
response = requests.request("GET",
random_stream_url,
headers=headers,
stream=True,
params=params)
print("is connected {}".format(response.status_code))
if response.status_code != 200:
raise Exception("Request returned an error: {} {}".format(
response.status_code, response.text))
for response_line in response.iter_lines():
if response_line:
json_response = json.loads(response_line)
while True:
if count == 0:
break
twitter_data: list = json_response.get("data")
if twitter_data.get("lang") == "en":
print(json.dumps(json_response, indent=4, sort_keys=True))
count += -1
try:
tweet = Tweet()
tweet.topic = topic
tweet.query_string = topic_example.title
tweet.text = twitter_data.get("text")
tweet.twitter_id = twitter_data.get("id")
tweet.save()
except IntegrityError:
pass
def create_user(screen_name=None):
screen_name = request.form["user"]
twitter_user = twitter_api_client.get_user(screen_name)
statuses = twitter_api_client.user_timeline(screen_name,
tweet_mode="extended",
count=150,
exclude_replies=True,
include_rts=False)
print("STATUSES COUNT:", len(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()
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))
# TODO: explore using the zip() function maybe...
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
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 render_template("user.html", user=db_user, tweets=statuses)
