def valid_ex(cls, user_data):
is_valid = True
if len(user_data['exercise_name']) < 2 or user_data['exercise_name'] == '':
is_valid = False
flash("Please Enter an Exercise Name", "ex_error")
if profanity.contains_profanity(user_data['exercise_name']) == True:
is_valid = False
flash("Please Enter an Appropriate Exercise Name", "ex_error");
if user_data['hour'] == '':
is_valid = False
flash("Please Enter Amount of Hours", "ex_error")
if user_data['minutes'] == '':
is_valid = False
flash("Please Enter Amount of Minutes", "ex_error")
if user_data['calories_burned'] == '':
is_valid = False
flash("Please Enter Est. Calories Burned", "ex_error")
if user_data['category'] == 'running' or user_data['category'] == 'walking' or user_data['category'] == 'cycling':
if user_data['miles'] == '' or user_data['miles'] == 0:
is_valid = False
flash("Please Enter Amount of Miles", "ex_error")
if user_data['category'] == 'weight_lifting':
if user_data['reps'] == '':
is_valid = False
flash("Please Enter Amount of Repetitions", "ex_error")
if user_data['sets'] == '':
is_valid = False
flash("Please Enter Amount of Sets", "ex_error")
if user_data['category'] == 'other':
if user_data['desc'] == '' or profanity.contains_profanity(user_data['desc']) == True:
is_valid = False
flash("Please Enter Valid Description", "ex_error")
return is_valid
def processDone(self):
global transcripts
global s2t
global fs
global data
wavlength = len(data) / float(fs)
ydata = [i[0] for i in data]
xdata = range(len(ydata))
graphLineColor = (200, 200, 234)
graphCriticalLineColor = (255, 128, 128)
timeCount = 0
for i in s2t:
dataPointLeft = int((timeCount / wavlength) * len(ydata))
dataPointRight = int((i[1] / wavlength) * len(ydata))
color = graphCriticalLineColor if profanity.contains_profanity(
i[0]) else graphLineColor
self.graphWidget.plot(xdata[dataPointLeft:dataPointRight],
ydata[dataPointLeft:dataPointRight],
pen=pg.mkPen(color=color))
timeCount = i[1]
self.transcriptBox.clear()
criticalBrush = QBrush(QColor(41, 41, 61))
for tr in transcripts:
item = QListWidgetItem(str(profanity.censor(tr)).capitalize())
if profanity.contains_profanity(tr):
item.setForeground(criticalBrush)
item.setBackground(QColor(255, 128, 128))
self.transcriptBox.addItem(item)
self.recordButtonOn = True
def analyze_titles(self):
start = time.time()
all_video_titles = self.main_channel_html.findAll(
"h3", {"class": "yt-lockup-title"})
video_titles = []
for i in range(10):
video_title = all_video_titles[i].text
if profanity.contains_profanity(video_title):
self.bad_words += 1
video_titles.append(video_title)
video_id = all_video_titles[i].findAll("a", href=True)
try:
transcript = YouTubeTranscriptApi.get_transcript(
self.get_video_id(video_id[0]['href']))
for j in range(len(transcript)):
if time.time() - start > 10:
break
if profanity.contains_profanity(transcript[j]["text"]):
self.bad_words += 1
except Exception as e:
print(e)
continue
end = time.time()
print("TIME FOR TITLES : " + str(end - start))
return video_titles
def validate_registration(post_data):
errors = {}
if len(post_data['first_name']) < 1 or post_data['first_name'] == '':
errors['first_name'] = "First Name must contain 2 letters or more"
if profanity.contains_profanity(post_data['first_name']) == True:
errors['bad_first_name'] = "Please Enter an appropriate First Name"
if len(post_data['last_name']) < 1 or post_data['last_name'] == '':
errors['last_name'] = "Last Name must contain 2 letters or more"
if profanity.contains_profanity(post_data['last_name']) == True:
errors['last_name'] = "Please Enter an appropriate Last Name"
if len(post_data['username']) < 4 or post_data['username'] == '':
errors['username'] = "******"
if profanity.contains_profanity(post_data['username']) == True:
errors['bad_username'] = "******"
if len(post_data['password']) < 7 or post_data['password'] == '':
errors['password'] = "******"
if post_data['password'] != post_data['conf_password']:
errors['conf_password'] = "******"
return errors
def test_custom_wordlist(self):
custom_badwords = ["happy", "jolly", "merry"]
profanity.load_censor_words(custom_badwords)
# make sure it doesn't find real profanity anymore
self.assertFalse(profanity.contains_profanity("F**k you!"))
# make sure it finds profanity in a sentence containing custom_badwords
self.assertTrue(profanity.contains_profanity("Have a merry day! :)"))
def create_post(request):
user = get_user(request)
if request.method == "POST":
received_json_data = json.loads(request.body, strict=False)
category = received_json_data["category"]
title = received_json_data["title"]
content = received_json_data["content"]
thumbnail = received_json_data["thumbnail"]
author = user
author_username = user.username
hidden = False
if profanity.contains_profanity(title) or profanity.contains_profanity(
content):
hidden = True
post = Post(category=Category.objects.get(name=category),
title=title,
content=content,
thumbnail=thumbnail,
author=author,
author_username=author_username,
hidden=hidden)
post.save()
if post:
data = {"id": post.id, "title": post.title}
return HttpResponse(json.dumps(data),
content_type="application/json")
return render(request, "create_post.html")
async def video(ctx, *, query):
search = SearchVideos(query, offset=1, mode="json", max_results=20)
results = json.loads(search.result())
l = []
t = []
tn = []
v = []
c = []
r = random.randint(0, 4)
for result in results["search_result"]:
l.append(result['link'])
t.append(result['title'])
tn.append(result['thumbnails'][0])
v.append(result['views'])
c.append(result['channel'])
embed = discord.Embed(title=t[r],
type='rich',
url=l[r],
colour=random.randint(0, 0xFFFFFF))
embed.set_footer(text=f"Views: {v[r]} | Made by {c[r]}.")
embed.set_thumbnail(url=tn[r])
if not ctx.channel.is_nsfw() and profanity.contains_profanity(
t[r]
) or not ctx.channel.is_nsfw() and profanity.contains_profanity(query):
await ctx.send('you need to be in a nsfw channel to seartch this')
else:
await ctx.send(embed=embed)
def post(self, request, pk, *args, **kwargs):
user = request.user
profile = Profile.objects.get(user=user)
group = Group.objects.get(pk=pk)
# Custom profanity words
custom_badwords = CustomProfanity.objects.values_list('bad_word',
flat=True)
profanity.load_censor_words(custom_badwords)
if 'submit_post_form' in request.POST:
post_form = PostForm(request.POST, request.FILES)
comment_form = None
valid = post_form.is_valid()
if profanity.contains_profanity(
post_form.cleaned_data.get('content')):
custom_profanity_error = 'Please remove any profanity/swear words. (Added by an admin. Contact an admin if you believe this is wrong.)'
valid = False
post_form.errors['content'] = custom_profanity_error
if valid:
post_instance = post_form.save(commit=False)
post_instance.author = profile
post_instance.group = group
post_instance.save()
return redirect('groups:view-group', pk=pk)
elif 'submit_comment_form' in request.POST:
comment_form = CommentForm(request.POST)
post_form = None
valid = comment_form.is_valid()
if profanity.contains_profanity(
comment_form.cleaned_data.get('body')):
custom_profanity_error = 'Please remove any profanity/swear words. (Added by an admin. Contact an admin if you believe this is wrong.)'
valid = False
comment_form.errors['body'] = custom_profanity_error
if valid:
post_id = request.POST.get("post_id")
comment_instance = comment_form.save(commit=False)
comment_instance.user = profile
comment_instance.post = Post.objects.get(id=post_id)
comment_instance.save()
return redirect(request.headers.get('Referer'))
group_posts = Post.objects.filter(group=group)
context = {
'profile': profile,
'group': group,
'posts': group_posts,
'post_form': post_form,
'comment_form': comment_form
}
return render(request, 'groups/view.html', context)
def profanity_word(text, lang):
if lang == 'vi':
profanity.load_censor_words_from_file('banned_word.text')
if profanity.contains_profanity(text):
return profanity.censor(text, '-')
return text
profanity.load_censor_words()
if profanity.contains_profanity(text):
return profanity.censor(text, '*')
return text
def search(query, type, limit, safe):
def googleSearch():
g_clean = []
if safe:
url = 'https://www.google.com/search?client=ubuntu&channel=fs&q={}&ie=utf-8&oe=utf-8'.format(
query)
else:
url = 'https://www.google.com/search?client=firefox-b-1-d&q={}&safe=images'.format(
query)
try:
html = requests.get(url)
if html.status_code == 200:
soup = BeautifulSoup(html.text, 'lxml')
a = soup.find_all('a')
for i in a:
k = i.get('href')
try:
m = re.search("(?P<url>https?://[^\s]+)", k)
n = m.group(0)
rul = n.split('&')[0]
domain = urlparse(rul)
if (re.search('google.com', domain.netloc)):
continue
else:
g_clean.append(rul)
except:
continue
except:
print(str(Exception))
finally:
return g_clean
y = 0
final = ''
for result in googleSearch():
if safe and profanity.contains_profanity(
result) or safe and profanity.contains_profanity(query):
final += ''
else:
if type == 'link':
if not result[-3] + result[-2] + result[-1] in [
'jpeg', 'jpg', 'png', 'gif'
]:
if y <= limit:
final += result + '\n'
y += 1
else:
if y <= limit:
final += result + '\n'
y += 1
return final
async def on_message(self, message):
def _check(m):
return (m.author == message.author and len(m.mentions)
and (datetime.utcnow() - m.created_at).seconds < 60)
if not message.author.bot:
if len(list(filter(lambda m: _check(m),
self.bot.cached_messages))) >= 2:
await message.channel.send("Don't spam mentions",
delete_after=15)
unmutes = await self.kick_members(message, [message.author],
reason="Mention spam")
elif profanity.contains_profanity(message.content):
await message.delete()
await message.channel.send("You can't use that word here",
delete_after=10)
elif message.channel.id not in self.links_allowed and search(
self.url_regex, message.content):
await message.delete()
await message.channel.send(
"You can't send links in this channel.", delete_after=10)
elif (message.channel.id not in self.images_allowed
and any([hasattr(a, "width") for a in message.attachments])):
await message.delete()
await message.channel.send(
"You can't send images in this channel.", delete_after=10)
async def on_message(message):
message_content = message.content.lower()
message_content = message_content.replace("*", "")
# Ignore empty messages like photos
if message_content == "":
return
if modules["lol"]:
if message_content == "lol" and str(message.author.id) == "756569562677510175" or devmode:
await message.channel.send('All hail TurtleDude!')
logger.debug(f"Lol triggered")
# Don't trigger on the bots messages
if message.author == bot.user:
return
if modules["swear"]:
logger.debug("Swear triggered")
Admin = discord.utils.get(message.guild.roles, name="Admin")
bot_builder = discord.utils.get(message.guild.roles, name="Bot Builder")
# Exempt og_squad and bot builder
if not Admin in message.author.roles or devmode:
if not bot_builder in message.author.roles or devmode:
# Uses Better Profanity to check if the string contains 1 or more bad words.
if profanity.contains_profanity(message_content):
await message.delete()
await user_strike_manager(message, userstrikes)
await counting(message)
await bot.process_commands(message)
async def on_message(self, message: discord.Message):
if self.bot.config["profanity-check"]:
if profanity.contains_profanity(message.content) and isinstance(message.channel, discord.TextChannel):
await message.delete()
# todo check if the content is longer than the max chars for the description
censored_content = profanity.censor(message.content, '\\*')
embed = discord.Embed(
title=f"I have deleted a message from {message.author.display_name} because it contains bad words! ",
description=f"Content of the message:\n||{censored_content}||\n\uFEFF",
colour=int(self.bot.config["embed-colours"]["default"], 16)
)
embed.set_footer(text="This message will delete itself after 15 seconds!")
await message.channel.send(embed=embed, delete_after=15)
if not await self.bot.check_message_reply(message, False):
return
prefix = self.bot.get_my_prefix(self.bot, message)
# if the bot gets mentioned it replies
if f"<@!{self.bot.user.id}>" in message.content:
await message.channel.send(embed=discord.Embed(
title=f"I If you need my help use `{prefix}help` to get a list of the available commands.",
colour=int(self.bot.config["embed-colours"]["default"], 16)
))
def process_crime(self, tweet_json):
"""
Process city-level CRIME scenario analysis on the tweet.
"""
text = tweet_json['text']
if profanity.contains_profanity(text):
self.analysis_result['crime']['vulgar_tweet_count'] += 1
async def filter_message(message):
mydb = databaseConnection()
mycursor = mydb.cursor()
profanity.add_censor_words(censored_words)
containsProfanity = False
if profanity.contains_profanity(message.content.lower()):
containsProfanity = True
if containsProfanity:
mycursor.execute("SELECT * FROM strikes WHERE user='******'".format(
message.author.name))
result = mycursor.fetchall()
count = 1
if result:
print('User: {} is in strikes table'.format(message.author.name))
for row in result:
count = row[1] + 1
sql = "UPDATE strikes SET count = {} WHERE user = '******'".format(
count, row[0])
mycursor.execute(sql)
else:
print("User: {} not in strikes table".format(message.author.name))
sql = "INSERT INTO strikes (user, count) VALUES (%s, %s)"
val = (message.author.name, count)
mycursor.execute(sql, val)
mydb.commit()
mydb.close()
await message.delete()
await message.channel.send(
"{}, your message has been deleted as it contains inappropriate text. And you have received a strike. Total Strikes: {}"
.format(message.author.mention, count))
def check_name(name):
# covers no user input
if len(name) < 1:
return False
# checks name for only letters
if any(chr.isalpha() == False for chr in name):
print("I think a name is supposed to have all letters!")
return False
# checks for profanity
if profanity.contains_profanity(name):
print("You shouldn't say that...")
return False
# asks user if name is correct; must enter yes or no
name_correct = input(f'Is {name}, correct? (yes/no)\n\n')
while True:
if name_correct == "yes" or name_correct == "no":
break
print("Please enter yes or no.")
name_correct = input(f'Is {name}, correct? (yes/no)\n\n')
if name_correct == "no":
return False
return True
async def on_message(self, message):
def _check(m):
return (m.author == message.author and len(m.mentions)
and (datetime.utcnow() - m.created_at).seconds < 60)
if not message.author.bot:
if len(list(filter(lambda m: _check(m),
self.bot.cached_messages))) >= 5:
await message.channel.send("No hagas SPAM de menciones!",
delete_after=10)
unmutes = await self.mute_members(message, [message.author],
5,
reason="SPAM de menciones")
if len(unmutes):
await sleep(5)
await self.unmute_members(message.guild, [message.author])
if profanity.contains_profanity(message.content):
await message.delete()
await message.channel.send("Mejora tú vocabulario por favor.",
delete_after=10)
elif message.channel.id not in self.links_allowed and search(
self.url_regex, message.content):
await message.delete()
await message.channel.send("No puedes enviar links aquí.",
delete_after=10)
def action_commands(commands):
for target in commands:
for command in commands[target]:
command_l = command.lower()
logger.info(f"processing command: {command_l}")
if profanity.contains_profanity(command_l):
send_message("Don't be rude or I'll eat all your crypto.", SIGNAL_USER, target)
elif command_l == "help":
send_message(textwrap.dedent(HELP_TEXT), SIGNAL_USER, target)
elif command_l.startswith("getprice") or command_l.startswith("gp"):
sep = command_l.startswith("gp") and "gp" or "getprice"
symbol = command_l.split(sep)[1].strip()
if not 3 <= len(symbol) <= 4 or not symbol.isalpha():
send_message("Symbol must contain alpha characters only and be 3 or 4 characters in length.", SIGNAL_USER, target)
continue
cmd = """coinmon -f %s | tail -n2 | head -n1 | sed 's/\x1B\[[0-9;]\{1,\}[A-Za-z]//g' | awk '{print $2, $4, $6, $8, $10, $12, $14}'""" % symbol
logger.debug(f"Fetching price for symbol: {symbol}")
p = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, close_fds=True)
p.wait()
result = p.stdout.read().decode('utf-8').strip()
if result:
rank, coin, price, change24h, marketcap, supply, volume24h = result.split()
response = f"Coin: {coin}\nRank: {rank}\nPrice USD: ${price}\nChange 24h: {change24h}\nMarket Cap: {marketcap}\nSupply: {supply}\nVolume 24h: {volume24h}"
else:
response = f"I've got no info about crypto symbol '{symbol}'. See coincap.io for a list of supported symbols."
send_message(response, SIGNAL_USER, target)
else:
cmd = f"{working_dir}/tuxi '{command}'"
p = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, close_fds=True)
p.wait()
response = p.stdout.read().decode('utf-8').strip().replace('\n', ' ')
if response == "No Result":
# just pass the question to the AI if Google doesn't have a featured snippet response
response = cb.single_exchange(command)
send_message(response, SIGNAL_USER, target)
async def on_message(self, message):
def _check(m):
return (m.author == message.author
and len(m.mentions)
and (datetime.utcnow() - m.created_at).seconds < 60)
if not message.author.bot:
if len(list(filter(lambda m: _check(m), self.bot.cached_messages))) >= 3:
await message.channel.send('Don`t spam mentions!', delete_after=10)
unmutes = await self.mute_members(message, [message.author], 5, 'Mention spam')
if len(unmutes):
await sleep(5)
await self.unmute_members(self.guild, [message.author])
if profanity.contains_profanity(message.content):
await message.delete()
await message.channel.send('You can`t use that word here', delete_after=10)
elif message.channel.id not in self.links_allowed and search(self.url_regex, message.content):
await message.delete()
await message.channel.send('You can`t send links to this channel', delete_after=10)
elif message.channel.id not in self.images_allowed and any([hasattr(a, 'width') for a in message.attachments]):
await message.delete()
await message.channel.send('You can`t send images here.', delete_after=10)
def listing_handler(video_id):
'''Handles profanity-check for a video with the given video id'''
response.headers['Content-Type'] = 'application/json'
response.headers['Cache-Control'] = 'no-cache'
text = ''
profanity_detected = False
censored_text = []
print(video_id)
transcript_list = YouTubeTranscriptApi.get_transcript(video_id)
# iterate over all available transcripts
for transcript in transcript_list:
text = transcript['text']
if profanity.contains_profanity(text):
profanity_detected = True
censored_text.append(profanity.censor(text))
result = {
'video-id': video_id,
'profanity-detected': profanity_detected,
'censored': censored_text
}
# return json.dumps({'names': list(_names)})
result = json.dumps(result)
## return template("<html>{{result}}", result)
return result
async def check_for_profanity(bot, msg):
if (
# message just has plain profanity
profanity.contains_profanity(msg) or
profanity.contains_profanity(
msg.replace(' ', '')) or # message has spaces and remove the spaces
profanity.contains_profanity(
re.sub(r'[^\w\s]', '', msg)) or # message has punctuation, remove punctuation
# message has invisible unicode character
profanity.contains_profanity(msg.replace('', '')) or
profanity.contains_profanity(
"".join(collections.OrderedDict.fromkeys(msg))) # duplicate chars
):
return True
return False
async def on_message(message):
mention = f'<@!{client.user.id}>'
if mention in message.content:
embed = discord.Embed(
description=
f"_{message.author.mention} :bell: You ping me, I ping you._",
color=6400)
await message.channel.send(embed=embed)
if str(message.channel) == "pictures" and message.content != '':
if message.author != client.user:
await message.channel.purge(limit=1)
embed = discord.Embed(
description=f"Sorry{message.author.mention}! Only Pictures!",
color=6400)
await message.channel.send(embed=embed)
else:
pass
if '' in message.content:
embed = discord.Embed(
title="Self Roles",
description="React to this message to get these roles! ")
if not message.author.bot:
if profanity.contains_profanity(message.content):
await message.delete()
embed = discord.Embed(
description=
f"{message.author.mention} :octagonal_sign: Mind your language!",
color=6400)
await message.channel.send(embed=embed)
await client.process_commands(message)
def on_status(self, status):
print(status)
direct_messages = api.list_direct_messages()
# For each direct message in the list, tweet out the message and then delete it.
for item in direct_messages:
print(item)
# check for profanity in the direct message before tweeting
if (not profanity.contains_profanity(
str(item.message_create['message_data']['text']))):
api.update_status(
str(item.message_create['message_data']['text']))
# delete the message so it is not tweeted multiple times
api.destroy_direct_message(item.id)
if ((not (api.get_status(status.id).retweeted))) and (
not profanity.contains_profanity(status.text)):
api.retweet(status.id)
def words(letters):
wList = []
gList = []
numWords = 0
for n in range(3, len(letters) + 1):
twList = []
tgList = []
for i in set(permutations(letters, n)):
temp = ''.join(i)
if d.check(
temp
) and temp not in wList and not profanity.contains_profanity(temp):
twList += [temp]
tgList += ["_" * n]
numWords += 1
if twList != []:
wList += [twList]
gList += [tgList]
if len(wList[-1]) > 0:
if letters in wList[-1]:
wList[-1].remove(letters)
gList[-1].pop()
numWords -= 1
if [] in wList:
wList.remove([])
gList.remove([])
return wList, gList, numWords
def get_tweets(self, query, count=100):
# An empty list to store the parsed tweets
tweets = []
try:
# Call Twitter API to fetch tweets
fetched_tweets = self.api.search(q=query, count=count)
# Parsing tweets
for tweet in fetched_tweets:
# Empty dictionary to store required parameters of a tweet
parsed_tweet = {
'text': tweet.text,
'sentiment': self.get_tweet_sentiment(tweet.text),
'profanity': profanity.contains_profanity(tweet.text),
'screen_name': tweet.user.screen_name,
'created_at': tweet.created_at
}
# Checking for retweets
# If a tweet has retweets append it only once
if tweet.retweet_count > 0:
if parsed_tweet not in tweets:
tweets.append(parsed_tweet)
else:
tweets.append(parsed_tweet)
return tweets
except tweepy.TweepError as e:
print("Error : " + str(e))
def result():
req = request.get_json()
# print(req)
as_string = req['input']
checked = "Yes" if profanity.contains_profanity(as_string) == True else "No"
# print(checked)
censored = profanity.censor(as_string, '🙉')
count = censored.count('🙉🙉🙉🙉')
# print(censored)
res = make_response(jsonify(f'Contains profanity? {checked}. Profanity count: {count}. Censored version: "{censored}"'), 200)
# custom = []
# profanity.add_censor_words(custom)
return res
return render_template("home.html")
async def speak(self, ctx, *, prompt=None):
if str(ctx.message.channel.type).lower() == "private":
return
if profanity.contains_profanity(prompt):
return
j = discord.utils.get(self.client.voice_clients,
guild=ctx.message.guild)
yeet = ctx.message.author.voice
if yeet == None or prompt == None:
await ctx.send("*no*")
return
channel = yeet.channel
if j == None:
await ctx.message.add_reaction('🤝')
await channel.connect()
#start playing
output = gTTS(text=prompt)
output.save("playing.mp3")
voice = discord.utils.get(self.client.voice_clients,
guild=ctx.message.guild)
await voice.play(
discord.FFmpegPCMAudio(
executable="ENTER PATH FOR FFMPEG EXECUTABLE",
source="./playing.mp3"))
await voice.disconnect()
return
async def on_message(self, message: Message):
def _check(m: Message):
return (m.author == message.author
and len(m.mentions)
and (datetime.utcnow() - m.created_at).seconds < 60)
if not message.author.bot:
# SPAM DETECTION - this method recommended for single server only, otherwise cpu+mem intensive
if len(list(filter(lambda m: _check(m), self.bot.cached_messages))) >= 3:
await message.channel.send(f"Mention span Detected ! \n" +
f"{message.author.mention} is muted for {self.mute_duration} minute(s).")
await self.mute_members(message, [message.author], self.mute_duration, "For spamming @mentions")
# await self.kick_or_ban_members(message, [message.author], "For spamming @mentions", mode="kick")
elif profanity.contains_profanity(message.content) and not message.content.find("delprofanity") == 1:
await message.delete()
await message.channel.send("You can't use this word here", delete_after=10)
elif message.channel.id in self.no_links_channels \
and search(self.url_regex, message.content) \
and not message.author.guild_permissions.manage_guild:
await message.delete()
await message.channel.send("You can't send links to this channel", delete_after=10)
elif message.channel.id in self.no_images_channels \
and any([hasattr(a, "width") for a in message.attachments]) \
and not message.author.guild_permissions.manage_guild:
await message.delete()
await message.channel.send("You cant post images in this channel", delete_after=10)
def chat(self, sentence):
if(profanity.contains_profanity(sentence)):
return self.bad_sentence()
sentence = tokenize(sentence)
X = bag_of_words(sentence, self.all_words)
X = X.reshape(1, X.shape[0])
X = torch.from_numpy(X).to(ChatBot.device)
# get result from model
output = self.model(X)
all, predicted = torch.max(output, dim=1)
tag = self.tags[predicted.item()]
probs = torch.softmax(output, dim=1)
prob = probs[0][predicted.item()]
print(
f'\nChatBot Prediction: \n\tsentence: {sentence} \n\tpredicted: {tag} \n\tprobability: {prob}\n')
if prob.item() > 0.75:
return self.make_response(tag)
else:
return self.no_intent_detected()
async def nickname_scanner(self, before, after):
if exceptionsManager.contains('exempt', after.nick):
return
if profanity.contains_profanity(
after.nick) or exceptionsManager.contains(
'restricted', after.nick):
log_channel = self.config.getint('Settings', 'channel')
if log_channel != -1:
await after.guild.get_channel(
log_channel).send('User ||' + before.name +
'|| tried to change nickname to ||' +
after.nick + '|| - action blocked.')
# Send Message
await after.send(
'The server ' + after.guild.name +
' detected that you tried to set a vulgar nickname. This action has been blocked. Please contact an administator if you feel this is an error.'
)
# Handle name edit back to previous value
try:
await after.edit(reason='Automated Protection',
nick=before.nick)
except (discord.Forbidden):
print("Could not change nickname")
if log_channel != -1:
await after.guild.get_channel(log_channel).send(
'Error, can not change nickname')
