def finlay(self):
"""
Because he is funny - Over 250 defintions.
"""
var = ran.randint(1, 5)
if var == 1:
defs = ud.define('Finlay')
defs = ran.choice(defs)
self.message(defs.definition)
if var == 2:
defs = ud.define('Finley')
defs = ran.choice(defs)
self.message(defs.definition)
if var == 3:
defs = ud.define('Finn')
defs = ran.choice(defs)
self.message(defs.definition)
if var == 4:
defs = ud.define('Findlay')
defs = ran.choice(defs)
self.message(defs.definition)
if var == 5:
defs = ud.define('Fin')
defs = ran.choice(defs)
self.message(defs.definition)
async def urban(ctx, *args):
logging.debug('Executing command {}urban'.format(prefix))
if args == (
): # If no arguments were passed, then respond with help message
help_string = (lg.urban[0].format(prefix))
return await ctx.send(help_string)
if len(args) >= 2:
args_list = list(args)
which_result = 1
possible_int = args_list.pop()
try:
which_result = int(possible_int)
except:
args_list.append(possible_int)
words = ' '.join(args_list)
defs = ud.define(
words
) # Using UrbanDictionary library to search for Urban Dictionary definitions
try:
definition = defs[
which_result -
1] # Selecting one result, based on which_result parameter (first result by default)
except IndexError:
await ctx.send(
lg.urban[1]
) # If index is out of range, then prints out that there was no result found
response = lg.urban[2].format(
definition
) # Reponse with some discord formatting for a nicer look
await ctx.send(response)
else:
words = ' '.join(args)
defs = ud.define(
words
) # Using UrbanDictionary library to search for Urban Dictionary definitions
try:
definition = defs[0]
except IndexError:
await ctx.send(
lg.urban[1]
) # If index is out of range, then prints out that there was no result found
response = lg.urban[2].format(
definition
) # Reponse with some discord formatting for a nicer look
await ctx.send(response)
def get_random_definition_from_urban_dictionary(self, search_query):
defs = ud.define(search_query)
if len(defs) > 0:
random_index = randint(0, len(defs))
return defs[random_index]
else:
return "No definition found for " % search_query
async def urban(ctx, *, query):
urbandefinition = ud.define(query)
ud_definition = urbandefinition[0].definition.replace('[',
'').replace(']', '')
ud_example = urbandefinition[0].example.replace('[', '').replace(']', '')
if len(ud_definition) > 1024:
ud_definition = ud_definition[:1021] + "..."
if len(ud_example) > 1024:
ud_example = ud_definition[:1021] + "..."
embed = discord.Embed(
colour=0xe86222,
title=urbandefinition[0].word,
url="https://www.urbandictionary.com/define.php?term={word}".format(
word=urbandefinition[0].word.replace(" ", "%20")))
embed.add_field(name="Definition", value=ud_definition, inline=False)
embed.add_field(name="Example", value=ud_example, inline=False)
embed.set_footer(text="{upvotes} 👍 {downvotes} 👎".format(
upvotes=urbandefinition[0].upvotes,
downvotes=urbandefinition[0].downvotes))
embed.set_author(
name="Urban Dictionary",
icon_url=
"https://cdn.discordapp.com/attachments/795406810844495944/799297576766799882/ud.png",
url="https://www.urbandictionary.com/")
await ctx.send(embed=embed)
async def urban(ctx, *, args=None):
author = ctx.message.author
msg = discord.Embed(colour=0xdaa520, description="")
msg.title = ""
msg.set_footer(text=footer_text)
if args == None:
msg.add_field(name=error_img,
value="Please give something you want to define.")
else:
if len(str(args)) > 150:
msg.add_field(
name=error_img,
value="The text cannot be longer than 150 characters.")
else:
try:
defs = ud.define('{}'.format(args))
msg.add_field(name=":bookmark_tabs: Urban Dictionary",
value="<@{}>: What is {}?\n \n{}".format(
author.id, args, random.choice(defs)))
except:
msg.add_field(
name=":bookmark_tabs: Urban Dictionary",
value="<@{}>: What is {}?\n \nNo definition found.".format(
author.id))
await client.say(embed=msg)
async def ud(ctx, *, definition):
defs = urbandictionary.define(definition)
#rand = urbandictionary.random()
defs = defs[0:4]
i = 1
result = ""
for d in defs:
s = d.definition.replace("[", "").replace("]", "").replace("\n", "")
result += f"{i}) {s}\n"
i += 1
e = discord.Embed(title="Definiton of " + definition,
description=result,
color=0XFFDF00)
"""
Checklist/plans:
- Incorporate embeded links if they're returned by the API instead of replacing the brackets.
- Check return type -> if "best def" or by likes
- Incorporate likes/dislikes
- Have pages rather than a spillage of definitions, 1 def/page -> might have to write a helper for paging, useful technique
- Footer will have link to definition page, simply the url
- Overload such that if nothing is passed in, call the random method
"""
await ctx.send(embed=e)
def ud(bot, channel, sender, args):
""" Defines you a word """
definition = urbandictionary.define(" ".join(args))[0]
bot.message(channel, "{}: {}".format(
definition.word,
definition.definition
))
def urbandictionary_lookup(bot, nick, word):
if not word:
bot.say(f"{nick} You must specify something to search")
return
defs = []
try:
defs = ud.define(word)
except Exception as e:
bot.say(f"{nick} {e}")
return
if len(defs) == 0:
bot.say(f"{nick} no results found for {word}")
return
filtered_defs = [
x for x in defs if x.word.strip().lower() == word.strip().lower()
]
if len(filtered_defs) == 0:
words = ', '.join(set([x.word.lower() for x in defs]))
bot.say(
f"{nick} no exact results for '{word}', possible matchs are: {words}"
)
return
filtered_defs.sort(key=lambda x: x.upvotes, reverse=True)
d = filtered_defs[0]
bot.say(
f"{BOLD}{d.word}{BOLD}: {ud_conv(d.definition)} {BOLD}Example{BOLD}: {ud_conv(d.example)}",
max_messages=3)
def ud(bot, channel, sender, args):
""" Defines you a word """
definition = urbandictionary.define(" ".join(args))[0]
bot.message(channel, "{}: {}".format(
definition.word,
definition.definition
))
def dictionary(request):
if request.method == "POST":
word = request.POST['word']
defs = ud.define(word)
return render(request, 'dictionary.html', {"word":word, "output":defs})
return render(request, 'dictionary.html', {})
async def urban(self, ctx, *, query):
self.defs = ud.define(query)
if not self.defs:
await ctx.send('No results.')
return
self.__create_embed(ctx)
await ctx.send(embed=self.embed)
def on_urban(self, event, phrase=None):
self.client.api.channels_typing(event.msg.channel_id)
urban_entry = None
if phrase is None:
urban_entry = random.choice(
ud.random()) # grab some random words | list of urbandef
else:
defs = ud.define(phrase)
if len(defs) > 0:
urban_entry = defs[0]
if urban_entry is None:
event.msg.reply('Failed to find a definition for that!')
else:
definition = urban_entry.definition
# Let's do a little... checking!
if len(definition) >= 2000:
definition = definition[:1950] + '...'
# Let's construct an embed :)
embed = MessageEmbed()
embed.title = f"**Defintion of {urban_entry.word}**"
embed.description = definition
embed.add_field(name='Example', value=urban_entry.example)
embed.add_field(
name='Rating',
value=f"{urban_entry.upvotes} 👍 | {urban_entry.downvotes} 👎")
embed.color = '5824574'
event.msg.reply(embed=embed)
def get_definition(title):
# defns = [clean_defn(x.definition) for x in ud.define(title)]
# ind = random.choice(xrange(len(defns)))
defn = clean_defn(ud.define(title)[0].definition)
defn = defn.capitalize().strip()
if not defn.endswith('.'):
defn += '.'
return defn
def urban(self, *args):
"""
Search urbandictionary, add your keywords after !urban
"""
try:
num = int(args[-1])
defs = ud.define(' '.join(list(args)[:-1]))
except Exception:
num = 2
defs = ud.define(' '.join(list(args)))
if num == 0:
num = len(defs)
defs = defs[:num]
for d in defs:
self.message(d.definition)
async def urban(ctx, message):
"""Search for stuff on Urban Dictionary"""
try:
async with message.channel.typing():
defs = ud.define(ctx.args.query)[0]
await message.channel.send(defs.definition)
except IndexError:
await message.channel.send("No definiton was found 😢")
def _get_slang(args):
if len(args) != 0:
slang_name = str(" ".join(args))
slang = ud.define(slang_name, embedd_link=True)[0]
else:
random_slangs = ud.random(embedd_link=True)
slang = random.choice(random_slangs)
return slang.word + "\n" + slang.definition + "\n"
async def urbandictionary(self, ctx, *, query):
result = ud.define(query)
result = result[0]
ud_embed = discord.Embed(
title=f"{query}",
description=f"{result.definition} \n*{result.example}*",
color=discord.Color.blue())
await ctx.send(embed=ud_embed)
def dictionary(request):
yash = ''
word = ''
if request.method == 'POST':
word = request.POST['word']
yash = ud.define(word)
return render(request, 'dictionary.html', {'word': yash, 'word1': word})
async def urbanBoi(self, context, rest: str = None):
if rest:
word = ud.define(rest)[0]
await self.bot.send_message(context.message.channel,
word.word + " " + word.definition)
else:
rando = ud.random()[0]
await self.bot.send_message(context.message.channel,
rando.word + " " + rando.definition)
def udict(bot:Bot, update:Update, args):
entity = " ".join(args)
defs = ud.define(entity)
required_definition = defs[0]
#definition = required_definition.definition
#example = required_definition.example
#word = required_definition.word
#update.message.reply_text("{} : {} . Example : {}".format(word[0], definition[0], example[0]))
update.message.reply_text(required_definition)
async def urban(self, ctx, *, word: str):
'Searches Urban Dictionary'
defs = ud.define(word)
for d in defs:
embed = discord.Embed(title=word,
description=d.definition,
color=745822)
embed.set_footer(text='Urban Dictionary')
await ctx.send(embed=embed)
async def ubdefine(self, ctx, *, string: str = None):
if ctx.message.channel.is_nsfw():
defs = ud.define(string)
if defs[0]:
await ctx.send('Here is what i found:\n```{}```'.format(
defs[0]))
else:
await ctx.send('I could not find anything.')
else:
await ctx.send('This is not a nsfw channel.')
async def urbandictionary(ctx, *, term):
definitions = ud.define(term)
await ctx.send(f"> **_{definitions[0].word.title()}_**")
for i in range(0, 3):
tempDef = definitions[i].definition.replace("[", "").replace(
"]", "").replace("\n", "\n> \t")
tempEx = definitions[i].example.replace("[",
"").replace("]", "").replace(
"\n", "\n> \t")
await ctx.send(f"> **{i+1}.** \n> \t{tempDef} \n> \t_\"{tempEx}\"_")
async def urban(self,ctx,*,arg):
defs = ud.define(f'{arg}')
d = defs[0]
def_final = d.definition.translate({ord(i): None for i in '[]'})
embed=discord.Embed(color=0xdf3908)
embed.set_author(name="Urban Dictionary",icon_url="https://i.pinimg.com/originals/37/46/41/374641157f9fa2ae904664d6c89b984b.jpg")
embed.add_field(name="Search", value=f"`{arg}`", inline=False)
embed.set_thumbnail(url="https://i.pinimg.com/originals/37/46/41/374641157f9fa2ae904664d6c89b984b.jpg")
embed.add_field(name="Result", value=f"`{def_final}`", inline=True)
await ctx.send(embed=embed)
def dictionary(request):
if request.method == "POST":
word = request.POST['word']
if word == "Bhavik":
defs = ( "definition": "Epitome of coolness. The coolest person one has ever seen." )
else:
defs = ud.define(word)
return render(request, 'dictionary.html', {"word":word, "output":defs})
return render(request, 'dictionary.html', {})
def urban_search(query,client,message):
result = ""
defs = ud.define(query)
if len(defs) == 0:
return sendMessage(client,message,"__Error 404: not found__")
for item in defs:
result += "**" + item.word + "**"
result += "\n**Definition:**\n" + item.definition + "\n"
result += "**Example:** __" + item.example + "__\n\n"
result += "++++++++++++++++++++++++++++++++\n"
return sendMessage(client,message,result)
def __init__(self, word, fullcmd):
print(f"searching for {word}")
self.word = word
try:
self.meaning = ud.define(word)[0].definition
utilities.SpeakText(
f"according to urban dictionary, {word} means {self.meaning}"
)
except Exception:
utilities.SpeakText(
f"oof, stupid urban dictionary doesn't even know the meaning of {word}."
)
def dictionary(request):
if request.method == "POST":
word = request.POST['word']
if word == "Bhavik":
defs = dict([("definition", 'Geeks')])
else:
defs = ud.define(word)
return render(request, 'dictionary.html', {
"word": word,
"output": defs
})
return render(request, 'dictionary.html', {})
async def ud(self, ctx, *, query):
'''Search terms with urbandictionary.com'''
em = discord.Embed(title=f'{query}', color=discord.Color.green())
em.set_author(name=ctx.author.name, icon_url=ctx.author.avatar_url)
em.set_footer(text='Powered by urbandictionary.com')
defs = ud.define(query)
try:
res = defs[0]
except IndexError:
em.description = 'No results.'
return await ctx.send(embed=em)
em.description = f'**Definition:** {res.definition}\n**Usage:** {res.example}\n**Votes:** {res.upvotes}:thumbsup:{res.downvotes}:thumbsdown:'
await ctx.send(embed=em)
def respond(message):
searchTerm = str(message.content).lower().split("define", 1)[1].strip()
definitions = urbandictionary.define(searchTerm)
if len(definitions) < 1:
definitions = urbandictionary.random()
output = definitions[0].definition.replace("[", "").replace("]", "")
output = ireplace(definitions[0].word, searchTerm, output)
return (output[:998] + '..') if len(output) > 1000 else output
def any_define(self, nick, chan, args):
replyto = self._replyto(nick, chan)
if not self.config.get('define_enabled', True):
self.send('PRIVMSG %s :no.' % replyto)
return
term = args
definition = list(urbandictionary.define(term))
if not definition:
self.send('PRIVMSG %s :%s is undefined' % (replyto, term))
else:
d = random.choice(definition)
self.send('PRIVMSG %s :%s' % (replyto, d.encode('utf-8', 'ignore')))
def search_urban_dictionary(token):
global stats
global urban_dictionnary_available
# maybe we just cannot use it?
if not urban_dictionnary_available:
return (False, None, None)
print("searching Urban Dictionary for ", token.lemma_)
stats['words searched Urban Dictionary'] = stats[
'words searched Urban Dictionary'] + 1
try:
blocksearch = False
searched = token.lemma_.lower()
defs = urbandictionary.define(searched)
if len(defs) > 0:
best = defs[0]
for d in defs:
if 'interjection' in d.definition or 'exclamation' in d.definition:
# Urban Dictionary has at least one definition saying this is an exclamation or interjection. We reject the word on this basis
blocksearch = True
stats['words rejected exclamation'] = stats[
'words rejected exclamation'] + 1
add_word_rejected_db(
token.lemma_,
"is interjection or exclamation for Urban Dictionary")
return (True, None, None)
if not d.word.lower().startswith(searched):
# this proposal is not
continue
print(d)
if (d.upvotes - d.downvotes) > (best.upvotes - best.downvotes):
best = d
if not blocksearch and best.word.lower().startswith(
searched
) and best.upvotes - best.downvotes > 20 and best.upvotes > 100: # enough votes for interest
pattern = re.compile('\[([\w]+)\]')
definition = pattern.sub(
'[\\1](https://www.urbandictionary.com/define.php?term=\\1)',
best.definition)
explanation = best.word + ': ' + definition # best.example
source = '[Urban Dictionary](https://www.urbandictionary.com/define.php?term=' + quote(
best.word) + ')'
stats['words found Urban Dictionary'] = stats[
'words found Urban Dictionary'] + 1
return (False, explanation, source)
except KeyError as e:
print("\terror with Urban Dictionary", e)
except urllib.error.URLError as e:
print("\tunable to connect Urban Dictionary", e)
return (False, None, None)
async def define(self, *, to_define: str):
"""Using Urban Dictionary, define stuff."""
to_define
defs = ud.define(to_define)
try:
tosend = '__**' + defs[0].word + ':**__\n'
tosend += defs[0].definition + ''
if defs[0].example:
tosend += '\n\n**Example:**\n' + defs[0].example
if len(tosend) >= 4000:
await self.bot.say("**Error:** Definition is too long to send, Sorry.")
else:
await self.bot.say(tosend)
except IndexError:
await self.bot.say('**Error:** Definition not found')
def urban_dict(message, raw):
if raw:
return
if len(message["arguments"]) < 2:
return "Syntax: udict_get <term>"
word = " ".join(message["arguments"][1:]).lower()
if word == " ":
return "Syntax: udict_get <term>"
try:
results = enumerated_join([u"{definition} (u{upvotes}d{downvotes}) -- Example: {example}".format(**d.__dict__) for d in ud.define(word)], start=1, sep="\n\n", default="Error: No definition!")
result = []
sr = ""
except IndexError:
return "Error: No definition!"
for r in results.split(" "):
sr += r + " "
if len(sr) > 100:
result.append(sr)
sr = ""
if result[-1] != sr:
result.append(sr)
try:
req = requests.post("http://hastebin.com/documents", data="\n".join(result), timeout=10)
except requests.exceptions.ConnectTimeout:
return "Connection to hastebin timed out!"
if req.status_code == 200:
return "Definition URL from Hastebin: http://hastebin.com/{}".format(req.json()['key'])
else:
return "Error status code! ({})".format(hastebin.status_code)
