async def talk(self, ctx, *, pussy:str):
"""talk to the bot"""
config = Config()
api_key = config.cb_api_key
cw = CleverWrap(api_key)
themessage = cw.say(pussy)
result = themessage.encode(encoding='UTF-8')
try:
await self.bot.say(str(ctx.message.author) + " >> " + cw.say(result))
except UnicodeDecodeError:
await self.bot.say("Error has occured trying to decode the Cleverbot message.")
async def mi(self, ctx, *, args):
'''No point in doing this, can be made better, but will be like this for the moment'''
cl_key = self.cleverbot_Key
cl_load = CleverWrap("{}".format(cl_key))
cl_resp = cl_load.say("{}".format(args))
await ctx.send(content=cl_resp)
cl_load.reset()
class Bot:
def __init__(self, tName, tColor, tVoice, tVoiceRate, tFilter):
self.mCb = CleverWrap("CCCsrAj9GISCVeMvQqFbE0IFc4w")
self.mName = tName
self.mColor = tColor
self.mVoice = tVoice
self.mVoiceRate = tVoiceRate
self.mFilter = tFilter
def ask(self, tQuestion):
#tQuestion = self.mFilter.removeUnicode(tQuestion)
tReply = self.mCb.say(tQuestion)
tReply = self.mFilter.filter(tReply)
self.type(tReply)
self.say(tReply)
return tReply
def type(self, tText):
print Colors.BOLD + self.mColor + self.mName + ": " + Colors.ENDC + self.mColor + tText + Colors.ENDC
def say(self, tText):
engine = pyttsx.init()
rate = engine.getProperty('rate')
engine.setProperty('rate', rate + self.mVoiceRate)
voices = engine.getProperty('voices')
engine.setProperty('voice', self.mVoice)
engine.say(tText)
a = engine.runAndWait()
def cleverSpeaks(stmt):
i = 0
try:
cw = CleverWrap(api_keys[i][1])
spoken = cw.say(stmt)
except requests.exceptions as e:
print(e)
return spoken
async def on_message(client, message):
print('[DEBUG: Cleverbot] in on_message')
if (message.content.startswith(CLEVERBOT_COMMAND)):
cw = CleverWrap("CC1cx7eaidCi0tvh7RfyC7eoYkA")
clvrbot_msg_cnt = message.content.split(CLEVERBOT_COMMAND)[1]
print("[DEBUG: Cleverbot] Calling Cleverbot with " + clvrbot_msg_cnt +
"...")
answer = cw.say(clvrbot_msg_cnt)
print("[DEBUG: Cleverbot] " + answer)
await client.send_message(destination=message.channel, content=answer)
#"Hello Human."
cw.reset() # resets the conversation ID and conversation state.
def chat(name):
cw = CleverWrap('API_KEY')
#random greetings to start off the conversation
greetings = [
"How are you doing today?", "What's up dude?", "How goes it?",
"How are you?", "What's on your mind?", "How's it hanging bro?",
"What's going on my dude?"
]
whats = [
"What was that?", "Come again?", "Could you repeat that?",
"I'm having a hard time hearing you.", "Please say that again.",
"What did you say?"
]
byes = [
"Good talking with you", "Until next time", "Goodbye",
"It's been a pleasure", "I enjoyed speaking with you", "So long",
"See you later"
]
engine = pyttsx3.init()
engine.setProperty('rate', 150)
engine.say(greetings[randrange(len(greetings))])
engine.runAndWait()
r = sr.Recognizer()
with sr.Microphone(device_index=7) as source:
while (1):
r.adjust_for_ambient_noise(source)
print("\n************** SPEAK NOW *************\n")
audio = None
text = None
try:
audio = r.listen(source)
print("Converting to text")
text = r.recognize_google(audio)
text = text.lower()
except sr.UnknownValueError as e:
engine.say(whats[randrange(len(whats))])
engine.runAndWait()
continue
print("You said: %s" % text)
if text == "good night sweet prince" or text == "goodnight sweet prince":
engine.say("%s %s" % (byes[randrange(len(byes))], name))
engine.runAndWait()
break
print("Thinking of a reply")
reply = cw.say(text)
print(reply)
engine.say(reply)
engine.runAndWait()
def chat(user, message):
global CW
try:
sendmessage("@" + user.name + " " + CW.say(message))
except:
sendmessage("Error gathering response. Trying again...")
try:
CW = CleverWrap(CLEVERBOT_API_KEY)
sendmessage("@" + user.name + " " + CW.say(message))
except:
sendmessage("Unable to get a response.")
def intent_talk(robot: cozmo.robot.Robot):
cb = CleverWrap(CLEVERBOT_API_KEY)
robot.say_text('What do you want to talk about?').wait_for_completed()
while True:
speech = csr.wait_for_speech(robot)
if csr.loose_matches_any(speech, ['bye', 'goodbye', 'good bye'], 1):
robot.say_text('Goodbye').wait_for_completed()
return
reply = cb.say(speech)
logger.info('Cleverbot says: %s' % reply)
robot.say_text(reply).wait_for_completed()
def cleverbot_reply(message):
tokenizer = nltk.data.load('tokenizers/punkt/english.pickle')
sentences = tokenizer.tokenize(message)
sentence = str()
smallest = 10000
for s in sentences:
l = 50 - len(s)
l *= l
if smallest > l:
sentence = s
smallest = l
sentence = re.sub('\W', ' ', sentence)
print("Idenitified sentence")
print(sentence)
# Get CLEVERBOT reply
cw = CleverWrap("CC1mmFptGklBB3wFbRtjhqGw7AA")
print("Req : " + sentence)
reply = (cw.say(sentence))
return reply
class Clever(object):
def __init__(self, client: commands.Bot):
self.clever = CleverWrap(basewrapper.Base().get_config_vars("CLEVER"))
self.client = client
client.clever_response = self.clever_response
async def clever_response(self, message):
response = self.clever.say(message)
msg = response
self.clever.reset()
return msg
@commands.command(pass_context=True)
async def clever(self, ctx: commands.Context, *, message: str):
await self.client.send_typing(ctx.message.channel)
response = await self.clever_response(message)
await self.client.say(f"{ctx.message.author.mention} {response}")
@commands.command(pass_context=True)
async def convo(self, ctx: commands.Context, *, msg: str):
await self.client.send_typing(ctx.message.channel)
response = await self.clever_response(message)
await self.client.say(f"{ctx.message.author.mention} {response}")
def test_say(mock_requests):
mock_requests.add(
mock_requests.GET,
'https://www.cleverbot.com/getreply?input=Hello&key=API_KEY&cs=&conversation_id=&wrapper=CleverWrap.py',
match_querystring=True,
json={
'cs': 'AAAABBCCDD',
'output': 'Hello.',
'interaction_count': "2",
'conversation_id': "foobar",
'time_taken': "15",
'time_elapsed': "13",
},
)
cw = CleverWrap("API_KEY")
assert cw.say("Hello") == "Hello."
assert cw.default_conversation.convo_id
cw.reset()
assert not cw.default_conversation.convo_id
class Fun:
"""Fun stuff."""
def __init__(self, bot):
self.bot = bot
self.config = bot.config
self.client = wolframalpha.Client(bot.config.app_id)
self.invalid_strings = ["Nobody knows.",
"It's a mystery.",
"I have no idea.",
"No clue, sorry!",
"I'm afraid I can't let you do that.",
"Maybe another time.",
"Ask someone else.",
"That is anybody's guess.",
"Beats me.",
"I haven't the faintest idea."]
self.cw = CleverWrap(bot.config.cwkey)
async def get(self, url, head=None):
async with aiohttp.ClientSession() as session:
async with session.get(url, headers=head) as response:
if response.status == 200:
data = response
return data
raise Exception(response.status)
@commands.command()
async def xkcd(self, ctx, number: int=None):
'''Get an xkcd comic.'''
if number and isinstance(number, int):
r = await self.get(url=f'https://xkcd.com/{number}/info.0.json')
elif number:
return await ctx.send('That\'s not a valid number!')
else:
raw = await self.get(url='https://xkcd.com/info.0.json')
r = await raw.json()
e = discord.Embed(title=r['safe_title'], description='xkcd - {}\n\n{}'.format(r['num'], r['alt']), color=ctx.author.color)
e.set_image(url=r['img'])
e.set_footer(text=f'{r["month"]}/{r["day"]}/{r["year"]} (mm/dd/yyyy)', icon_url='https://i.imgur.com/9sSBA52.jpg')
await ctx.send(embed=e)
@commands.command()
async def ship(self, ctx, user: discord.User, user2: discord.User):
'''Ships 2 people'''
async with aiohttp.ClientSession() as session:
async with session.post('https://api.weeb.sh/auto-image/love-ship', headers={'Authorization': f'Wolke {self.config.weebsh}'}, data={'targetOne': user.avatar_url, 'targetTwo': user2.avatar_url}) as response:
t = await response.read()
with open("ship.png", "wb") as f:
f.write(t)
with open("ship.png", "rb") as f:
if random.randint(0, 1) == 0:
pf = random.randint(0, 100)
else:
pf = fuzz.ratio(user.name, user2.name)
p = f'[{"".join("#" for x in range(round(pf/10)))}{"".join(" " for x in range(10-round(pf/10)))}] {pf}%'
await ctx.send(f'**{user.name}** x **{user2.name}**\nLove Meter: \n`{p}`', file=discord.File(fp=f))
@commands.command()
async def waifuinsult(self, ctx, user: discord.User=None):
'''Insult your own(or somebody elses) waifu'''
if not user:
user = ctx.author
async with ctx.typing():
async with aiohttp.ClientSession() as session:
async with session.post('https://api.weeb.sh/auto-image/waifu-insult', headers={'Authorization': f'Wolke {self.config.weebsh}'}, data={'avatar': user.avatar_url}) as response:
t = await response.read()
with open("waifuinsult.png", "wb") as f:
f.write(t)
with open("waifuinsult.png", "rb") as f:
await ctx.send(file=discord.File(fp=f))
@commands.command(aliases=['c', 'cbot'])
async def clever(self, ctx, *, message):
'''Say something to cleverbot.'''
async with ctx.typing():
await ctx.send(self.cw.say(message))
@commands.command()
async def cat(self, ctx):
'''Get a random cat image.'''
try:
fact = await self.get(url='https://catfact.ninja/fact')
fact = await fact.json()
e = discord.Embed(color=ctx.author.color, description=fact['fact'])
except:
self.bot.raven.CaptureException()
await ctx.send('Something went wrong while getting your cat fact!')
try:
resp = await self.get(url='http://aws.random.cat/meow')
resp = await resp.json()
e.set_image(url=resp['file'])
except:
self.bot.raven.CaptureException()
await ctx.send('Something went wrong while getting your cat image!')
e.set_footer(text='Powered by random.cat')
await ctx.send(embed=e)
@commands.command()
async def dog(self, ctx):
'''Get a random dog image.'''
e = discord.Embed(color=ctx.author.color)
resp = await self.get(url='https://random.dog/woof.json')
resp = await resp.json()
e.set_image(url=resp['url'])
e.set_footer(text='Powered by random.dog')
await ctx.send(embed=e)
@commands.command()
async def birb(self, ctx):
'''Get a random birb image.'''
e = discord.Embed(color=ctx.author.color)
resp = await self.get(url='https://random.birb.pw/tweet.json')
resp = await resp.json(content_type='text/plain')
e.set_image(url=f'https://random.birb.pw/img/{resp["file"]}')
e.set_footer(text='Powered by random.birb.pw')
await ctx.send(embed=e)
@commands.command()
async def neko(self, ctx):
'''Gets a random neko :3'''
e = discord.Embed(color=ctx.author.color)
resp = await self.get(url='https://nekos.life/api/neko')
resp = await resp.json()
e.set_image(url=resp['neko'])
e.set_footer(text='Powered by nekos.life')
await ctx.send(embed=e)
@commands.command()
@commands.is_nsfw()
async def lewdneko(self, ctx):
'''Gets a random lewd neko o.o'''
e = discord.Embed(color=ctx.author.color)
resp = await self.get(url='https://nekos.life/api/lewd/neko')
resp = await resp.json()
e.set_image(url=resp['neko'])
e.set_footer(text='Powered by nekos.life')
await ctx.send(embed=e)
@commands.command()
async def weeb(self, ctx, type=None):
'''Fetch a type from weeb.sh. Call without args to get a list of types.'''
head = {'Authorization': f'Wolke {self.config.weebsh}'}
types = self.config.weebtypes['types']
if type:
if type in types:
e = discord.Embed(color=ctx.author.color)
resp = await self.get(url=f'https://api.weeb.sh/images/random?type={type}', head=head)
resp = await resp.json()
e.set_image(url=resp['url'])
e.set_footer(text='Powered by weeb.sh')
await ctx.send(embed=e)
else:
await ctx.send(f'```{types}```')
else:
await ctx.send(content=f'```{types}```')
@commands.command()
async def osu(self, ctx, *, user):
try:
respraw = await self.get(url=f'https://osu.ppy.sh/api/get_user?k={self.config.osu}&u={user}')
respraw = await respraw.json()
resp = respraw[0]
except Exception as e:
await ctx.send(f'S-something went wrong!\n```py\n{e}```')
return
username = resp.get('username', 'Error occured')
userid = resp.get('user_id', 'Error occured')
try:
acc = resp.get('accuracy', '0')
accuracy = f'{round(float(acc))}%'
except:
accuracy = 'Not Available'
timesplayed = resp.get('playcount', 'Error occured')
country = resp.get('country', 'Error occured')
pp = resp.get('pp_rank', 'Error occured')
level = resp.get('level', 'Error occured')
ranked_score = resp.get('ranked_score', 'Error occured')
total_score = resp.get('total_score', 'Error occured')
stats = {'Username': str(username),
'ID': str(userid),
'Accuracy':str(accuracy),
'Times Played': str(timesplayed),
'Country':str(country),
'PP':pp,
'Level':str(level),
'Ranked Score':str(ranked_score),
'Total Score':str(total_score),
}
e = discord.Embed(title=f'osu! stats for {username}', description='osu! stats\n', color=ctx.author.color)
for stat in stats:
e.add_field(name=stat, value=stats[stat])
await ctx.send(embed=e)
@commands.command()
async def wolfram(self, ctx, *, query):
"""Query Wolfram Alpha."""
def q(query):
res = self.client.query(query)
return res
async def async_q(query):
thing = functools.partial(q, query)
return await self.bot.loop.run_in_executor(None, thing)
res = await async_q(query)
e = discord.Embed(title="Wolfram|Alpha", description="", color=ctx.author.color)
def invalid():
e.add_field(name="Query", value=query, inline=False)
e.add_field(name="Result", value=random.choice(self.invalid_strings)+"`(Invalid or undefined query)`", inline=False)
try:
r = next(res.results).text
if r == "(undefined)" or r == "(data not available)":
invalid()
else:
e.add_field(name="Query", value=query, inline=False)
e.add_field(name="Result", value=r, inline=False)
except:
invalid()
await ctx.send(embed=e)
from cleverwrap import CleverWrap
API_KEY_1 = "CC22xhxFPYAVVMo9i7hPn8bZxpw"
API_KEY_2 = "CC232J2D3dL0YQjF2i8HkPRj92w"
jas = CleverWrap(API_KEY_1)
malgosia = CleverWrap(API_KEY_2)
ans = input("Reset speach ID? [Y/N]: ")
if ans.lower() == 'y':
jas.reset()
malgosia.reset()
print("Done...")
malgosia_talk = "Hi"
for i in range(500):
jas_talk = jas.say(malgosia_talk)
print("[jas] >> ", jas_talk)
malgosia_talk = malgosia.say(jas_talk)
print("[{}][malgosia_talk] >> ".format(i), malgosia_talk)
time.sleep(1)
# response = []
# with open('questions.txt', 'r', encoding='utf8') as f:
# response = f.read().splitlines()
#
# for i in range(100):
# talk = random.choice(response)
# print(talk)
# response.append(jas.say(talk))
# print("[{}/100]>>>".format(i), response[-1])
# i += 1
# python chatBot.py
# then just type after the > prompt
# to leave, type > I'm leaving
from cleverwrap import CleverWrap
chatBot = CleverWrap("CC6zkRgO9TPlPcz6AO_zLCunNBg")
import subprocess
import sys
shell = True
#chatBot.reset()
def speak(this):
print('- '+str(this))
subprocess.run(['flite', '-voice', 'file://cmu_us_aew.flitevox', '-t', str(this)])
speak('I\'m listening')
var = input('> ')
chatting = True
while chatting == True:
if(var == 'I\'m leaving'):
chatting = False
break
reply = chatBot.say(str(var))
speak(reply)
var = input('> ')
speak("Fine, leave. See if I care.")
def test_api_error(mock_requests):
cw = CleverWrap("API_KEY")
with pytest.raises(UnknownAPIError):
cw.say("Hello")
def c_cleverbot(client, message):
cw = CleverWrap(cleverbot_key)
yield from client.send_message(
message.channel,
sh.mention(message) + cw.say(sh.get_args(message)))
def callAI(msg):
cw = CleverWrap("CC8e31EaiwH16_bIY62-b0FesWw")
return cw.say("You" + msg + "?")
logger.error('Failed to send tweet', exc_info=True)
def strip_user_handles(text):
"""Function strips user handles from incoming tweet"""
pattern = r'\B@\w+ *'
result = re.sub(pattern, '', text)
logger.debug('strip_user_handles: input:{}, output:{}'.format(
text, result))
return result
if __name__ == '__main__':
print('~ TwitterBot is now running ~\n')
try:
for tweet in api.GetStreamFilter(
track=[str(arguments.twitter_handle)]):
response = cleverbot.say(strip_user_handles(tweet['text']))
send_tweet(
tweet['user']['screen_name'],
response,
tweet_id=tweet['id'] if arguments.reply_to_thread else None)
logger.debug('Tweet: {}'.format(tweet))
logger.info('Incoming tweet from {}: {}'.format(
tweet['user']['screen_name'], tweet['text']))
logger.info('Reply: {}'.format(response))
except KeyboardInterrupt:
print('\n~ Quitting ~')
driver.get("http://www.tokyochronos.net/cute/thread/2579/")
##Find last post in thread
elements = driver.find_elements_by_xpath("//div[contains(@class, 'text')]")
size = len(elements)
target_element = elements[size - 1]
##Pokemon stuff
mystfuline = (target_element.text)
mystfulinestripped = (mystfuline).lstrip()
driver.close()
my_humanresponse = print(mystfulinestripped)
my_cleverresponse = cw.say(mystfulinestripped)
print(my_cleverresponse)
##Fuuka functionality
driver = webdriver.Firefox(options=options)
driver.get("http://www.tokyochronos.net/cute/thread/2579/")
replybox = driver.find_element_by_id("reply_chennodiscursus")
replybox.send_keys(my_cleverresponse)
replyboxN = driver.find_element_by_id("reply_bokunonome")
replyboxN.send_keys("Arc#0")
replyboxFile = driver.find_element_by_id("file_image")
'I will keep doing this until meet your limit',
'show me what your can do',
'come on!'
]
responses = []
CW = CleverWrap("CC5rkRh9_2fJ05hSgbaQ6DOCAig")
L = len(contexts)
start = time.time()
for i in range(1):
try:
#responses.append(contexts[i%L])
resp = CW.say(text)
responses.append(resp)
print(resp)
except Exception as e:
responses.append('xxxxx')
end = time.time()
print(start)
print(end)
with open('resp.txt','w') as f:
f.write(str(end-start))
f.write('\r\n')
for r in responses:
f.write(r)
f.write('\r\n')
class ChatService(Service):
"""
Service responsible for dealing with
'CleverBot' and responding to users
Parameters
-----------
bot: Bunkbot
Super class instance of the bot
database: DatabaseService
Super class instance of the database service
users: UserService
Instance of the user service for retrieving user information
channels: ChannelService
Instance of the channel service to send responses back to the server
time: TimeService
/time
"""
def __init__(self, bot: BunkBot, database: DatabaseService, users: UserService, channels: ChannelService, time: TimeService):
super().__init__(bot, database)
self.chat_bot: CleverWrap = None
self.chats: List[Chat] = []
self.users: UserService = users
self.channels: ChannelService = channels
self.time: TimeService = time
self.bot.on_initialized += self.setup_chat_helper
self.config.raise_error_on_bad_config = False
#DaemonHelper.add(self.randomly_create_conversation, trigger="interval", hours=INTERVAL_FOR_RANDOM_CHAT)
async def setup_chat_helper(self) -> None:
"""
Upon initialization of the bot, connect to the cleverbot through
the CleverWrap package if the configuration has been setup with a valid key
"""
chat_token = self.config.cleverbot_api_key
if chat_token is not None:
self.chat_bot = CleverWrap(chat_token, self.bot.name)
self.bot.on_user_message += self.respond_to_message
else:
await self.channels.log_warning("Cleverbot token not supplied, BunkBot will be mute :(")
async def respond_to_message(self, message: Message) -> None:
"""
If configured, each user message into the service will be analyzed
if the user is either attempting to send a command, start a conversation
with the bot, or continue an existing conversation
Parameters
-----------
message: Message
Discord Message object sent from the bot event when a user sends a chat message
"""
if not message.author.bot:
if message.content.startswith("!"):
await self.bot.process_commands(message)
elif message.content == "/time" and is_stupid_mkr(message.author.name):
await message.channel.send(await self.time.get_time(message))
else:
user: BunkUser = self.users.get_by_id(message.author.id)
chat: Chat = next((c for c in self.chats if c.user.id == user.id and c.channel_id == message.channel.id), None)
is_bunk_mention: bool = len(message.mentions) > 0 and message.mentions[0].name.lower() == self.bot.name.lower()
parsed_chat: list = Chat.parse(message.content)
bunk_name_index: int = -1
try:
bunk_name_index = parsed_chat.index(self.bot.name_lower)
except:
bunk_name_index = -1
if is_bunk_mention or bunk_name_index > -1:
if chat is None:
chat = Chat(user, message)
self.chats.append(chat)
is_first = is_bunk_mention or bunk_name_index == 0
is_last = is_bunk_mention or bunk_name_index == len(parsed_chat)-1
is_one_time_response = not is_first and not is_last
will_respond: bool = True
if is_one_time_response:
will_respond = randint(0, 100) >= 50
if will_respond:
await self.respond(chat, message, user)
if is_one_time_response:
chat.last_message_at = -1
self.chats.remove(chat)
else:
if chat is not None and chat.channel_id == message.channel.id:
if chat.is_active:
if message.content.lower() == "quiet":
chat.last_message_at = -1
self.chats.remove(chat)
await message.channel.send(":face_with_hand_over_mouth:")
else:
await self.respond(chat, message, user)
else:
self.chats.remove(chat)
else:
await self.bot.process_commands(message)
async def respond(self, chat: Chat, message: Message, user: BunkUser) -> None:
"""
After careful analysis of conversation with the bot, respond to
a user with the CleverBot API. If the bot is idle, wake his ass up
Parameters
-----------
chat: Chat
Stateful chat object between a user and the bot
message: Message
Instance of the last sent message by the user
user: BunkUser
User currently holding a conversation with the bot
"""
try:
if self.bot.member_ref.status == Status.idle:
will_wakeup: bool = will_execute_on_chance(40)
if not will_wakeup:
return
await self.bot.change_presence(status=Status.online, activity=None)
await message.channel.trigger_typing()
content: str = self.override(message)
response: str = self.chat_bot.say(chat.reply(content, user))
response = self.alter_response(user, response)
self.update_inactive_chats()
await message.channel.send(response)
except Exception as e:
await self.channels.log_error(e, "ChatService")
await message.channel.send("I'm sorry... I cannot talk right now")
def alter_response(self, user: BunkUser, response: str) -> str:
if not response[-1] in punctuation:
return response
if len(self.chats) > 1 and will_execute_on_chance(80):
response = "{0}, {1}{2}".format(response[:-1], user.name, response[-1])
return response
async def randomly_create_conversation(self) -> None:
"""
Every N configured hours, random decide to ping someone (with an exclude list)
who is online and not gaming
TODO - Not currently implemented or in use
"""
users: List[BunkUser] = []
for member in self.bot.server.members:
user: BunkUser = self.users.get_by_id(member.id)
if user is not None and user.is_online and not user.is_gaming:
print("SNAG EM {0}".format(user.name))
users.append(user)
user: BunkUser = users[randint(0, len(users)-1)]
def update_inactive_chats(self) -> None:
for chat in self.chats:
if not chat.check_if_active():
self.chats.remove(chat)
@staticmethod
def override(msg: Message) -> bool:
"""
Override possible commands so that the
bot can respond instead of attempting to
parse the command
Paramters
----------
msg: Message
Message/command to override
"""
content: str = msg.content.split()[0]
if content == "!duel":
return "Duel me you coward!"
return msg.content
class speak:
def __init__(self, google_apikey, cleverbot_apikey):
self.cleverbot_apikey = cleverbot_apikey
self.google_apikey = google_apikey # apikey failinimi
self.gui = Tk() # tkinteri init
self.record_btn_text = StringVar()
self.wait_var = IntVar()
self.running = True
def Main(self):
self.gui.title("Action")
self.gui.geometry("500x500")
self.wait_var = IntVar()
start_btn = ttk.Button(self.gui,
text="Start",
command=lambda: self.wait_var.set(1))
start_btn.grid(row=0, ipadx=210)
exit_button = ttk.Button(self.gui, text='Exit', command=self.shutdown)
exit_button.grid(row=1, column=0, ipadx=210)
start_btn.wait_variable(
self.wait_var) # ootab et start nuppu vajutataks
empty_line = Label(self.gui, text='') # tühi rida vahele
empty_line.grid(row=2)
speech_array = []
while self.running: # mainloop() asenduseks et GUI püsiks
self.record_btn_text.set('Start listening')
record_btn = ttk.Button(self.gui,
textvariable=self.record_btn_text,
command=self.wait)
record_btn.grid(row=0, ipadx=210)
record_btn.wait_variable(self.wait_var)
if self.running:
speech = self.recognize()
else:
exit(0)
if speech == 'exit ':
exit(0)
response = self.cleverbot(speech)
if speech is None:
continue
speech = 'You: ' + speech
response = 'Cleverbot: ' + response
speech_array.append(Label(self.gui, text=speech))
speech_array.append(Label(self.gui, text=response))
if len(speech_array) > 20:
speech_array.pop(0).destroy()
speech_array.pop(0).destroy()
for i in range(3, len(speech_array) + 3):
speech_array[i - 3].grid(row=i)
self.gui.update_idletasks()
self.gui.update()
def recognize(self):
# aktiveerib mikrofoni ja kuulab kuni on vaikus
r = sr.Recognizer()
r.dynamic_energy_threshold = True
with sr.Microphone() as source:
print('Started listening.')
audio = r.listen(source, phrase_time_limit=5)
print("Stopped listening.")
self.record_btn_text.set('Stopped listening')
self.gui.update()
try:
credentials = open(self.google_apikey).read()
except FileNotFoundError:
print(self.google_apikey, 'file not found')
exit(1)
try:
speech_to_text = r.recognize_google_cloud(
audio, credentials_json=credentials)
except sr.UnknownValueError:
print("Google Cloud Speech could not understand audio")
return None
except sr.RequestError as e:
print(
"Could not request results from Google Cloud Speech service; {0}"
.format(e))
raise FileNotFoundError
return speech_to_text
def cleverbot(self, speech):
self.record_btn_text.set('Waiting for cleverbot response...')
self.gui.update()
try:
self.cw = CleverWrap(open(self.cleverbot_apikey).read())
except FileNotFoundError:
print(self.cleverbot_apikey, 'file was not found')
raise FileNotFoundError
vastus = self.cw.say(speech)
return vastus
def wait(self):
self.record_btn_text.set('Listening now')
self.wait_var.set(1)
self.gui.update()
def shutdown(self):
self.running = False
self.cw.reset()
self.wait_var.set(2)
class TFMBot(TFMProtocol):
"""
TFMBot application itself
"""
def __init__(self, *args, **kwargs):
TFMProtocol.__init__(self, *args, **kwargs)
self.factorylist = kwargs["factorylist"]
self.username = "******"
self.password = "******"
self.player_bot = True
self.room = "*dizzy bootcamp"
self.requests = {"tribe_otfm": False, "stafflist": False}
self.loops = {}
self.staff_list = {"mods": {}, "mapcrew": {}}
self.chat_list = {}
self.td = self.get_tfm_info()
self.cb = CleverWrap("clever_key")
def get_tfm_info(self):
with open("transformice/tfminfo.json") as f:
return json.load(f)
def save_tfm_info(self):
with open("transformice/tfminfo.json", "w") as f:
json.dump(self.td, f, sort_keys=True, indent=2)
def save_staff_api(self):
try:
with open("/home/edizzy12/www/riddlematic.com/html/staff.json",
"w") as f:
json.dump(self.staff_list, f, sort_keys=True, indent=2)
except:
pass
def get_chat_list(self):
return self.chat_list
def get_protocol(self, which):
self.factorylist.get_factory_protocol(which)
def on_connection_made(self, name):
def api_checker():
self.send_command("mod")
reactor.callLater(1, self.send_command, "mapcrew")
self.loops["api checker"] = LoopingCall(api_checker)
self.loops["api checker"].start(60)
reactor.callLater(2.5, self.join_chat, "#help")
reactor.callLater(3.5, self.join_chat, "#dm-help")
def on_connection_lost(self, name):
if name == "transformice":
for name, loop in self.loops.iteritems():
loop.stop()
def on_login(self, player_id, bot_name, time_played, community,
temp_player_id, mod_level, public_staff, levels):
log.info("I am online!")
reactor.callLater(5, self.join_tribehouse)
self.send_command("chat ediztest")
def got_room_address(self, ip, key):
if "bulle" in self.factorylist.factories:
self.factorylist.factories["bulle"].stop_connection()
self.factorylist.factories["bulle"].connector.disconnect()
self.factorylist.add_factory(
"bulle",
Factory(TFMBot,
ip,
44444,
key,
data=self.factorylist.tfm_data,
factorylist=self.factorylist))
self.factorylist.start_factory("bulle")
def on_join_chatroom(self, chat_id, chat_name):
if chat_name.lower() == "~too cute to be real":
chat_name = "tribe"
self.chat_list[chat_name] = chat_id
def on_tribe_message(self, name, message):
message = message.replace("<", "<").replace("&", "&")
name, id = name.split("#")
log.info("[TRIBE][%s] %s" % (name, message))
self.bridge_chat_message(name, message, "tribe")
if message.startswith("!"):
args = message[1:].split()
request = args[0].lower()
if request in ["odiscord", "od"]:
self.get_online_discord()
elif request in ["otfm", "ot"]:
self.request_tribe_members_list()
self.requests["tribe_otfm"] = True
elif request == "8ball":
self.send_tribe_message(self.eightball(args[1:]))
elif request == "omsg":
self.send_tribe_message(self.add_offline_message(
name, message))
elif request == "tw" and name.lower() in self.td["leaders"]:
self.send_tribe_message(self.change_tribe_welcome(message))
else:
if message.lower().startswith("dizzy,"):
self.send_tribe_message(
self.cb.say(message.replace("dizzy,", "")).encode("utf8"))
def on_tribe_connect(self, name):
name, id = name.split("#")
message = "%s has connected." % (name.capitalize())
log.info(message)
self.bridge_chat_message("Server", str(message), "tribe")
try:
greet = random.choice(self.td["greets"][name.lower()])
except KeyError:
greet = random.choice(self.td["greets"]["tribe"])
self.send_tribe_message(("%s ❤".decode("utf8") % greet).encode("utf8"))
if name.lower() in self.td["offline-messages"]:
text = "You have following messages from tribe:\n"
for msg in self.td["offline-messages"][name.lower()]:
text += msg + "\n"
self.remove_offline_message(name.lower())
self.send_private_message(name, str(text))
def on_tribe_disconnect(self, name):
message = "%s has disconnected." % (
name.capitalize()) # self.td["gameIDs"][str(game_id)]
log.info(message)
self.bridge_chat_message("Server", str(message), "tribe")
def on_tribe_join(self, name):
message = "%s has joined the tribe." % name.capitalize()
log.info(message)
self.bridge_chat_message("Server", message, "tribe")
def on_tribe_quit(self, name):
message = "%s has left the tribe." % name.capitalize()
log.info(message)
self.bridge_chat_message("Server", message, "tribe")
def on_tribe_kick(self, kicked_person, who_kicked):
message = "%s has excluded %s from the tribe." % (
who_kicked.capitalize(), kicked_person.capitalize())
log.info(message)
self.bridge_chat_message("Server", message, "tribe")
def on_tribe_greeting_change(self, name, text):
message = "%s has changed the greeting message:\n %s" % (
name.capitalize(), text)
log.info(message)
self.bridge_chat_message("Server", message, "tribe")
def on_tribe_list(self, tribe, members, ranks):
if self.requests["tribe_otfm"]:
online = []
for name, member in members.iteritems():
# print "%s: %s" % (name, time.strftime("%Z - %Y/%m/%d, %H:%M:%S", time.localtime(member["last connection"] * 60)))
if member["game"] > 1:
online.append(name)
random.shuffle(online)
g = random.choice(
["Online TFM peeople", "Online TFM peeps", "Online TFM dudes"])
online = ", ".join(online)
self.send_tribe_message("%s: %s" % (g, online))
self.requests["tribe_otfm"] = False
def on_chat_message(self, name, community, channel, message):
message = message.replace("<", "<").replace("&", "&")
name = name.replace("#0000", "") # UNIQUE ID
community = str(self.td["communityIDs"][str(community - 1)].upper())
log.info("[%s][%s][%s] %s" % (channel, community, name, message))
if channel == "help" or channel == "dm-help":
self.bridge_chat_message(
name, "[%s][%s] %s" % (community, name, message),
"chat|%s" % channel, "helpers_discord")
if name.lower() != self.username.lower():
pass
def on_room_message(self, user_id, name, message):
self.bridge_chat_message(name, message, "room")
log.info("[%s] %s" % (name, message))
if name.lower() != self.username.lower():
if message.startswith("!"):
args = message[1:].split()
request = args[0].lower()
if request == "emote" and len(args) > 1:
emote = args[1].lower()
try:
if emote == "flag" and len(args) == 3:
self.send_emote(self.td["emoteIDs"][emote],
args[2])
elif emote == "help":
allowed_emotes = ", ".join(
self.td["emoteIDs"].keys())
self.send_room_message("Allowed emotes: %s" %
str(allowed_emotes))
else:
self.send_emote(self.td["emoteIDs"][emote])
except KeyError:
self.send_room_message(
"Unknown emote \"%s\". Type !emote help for a list of emotes."
% emote)
elif request == "testlua":
self.send_lua("http://pastebin.com/RtT5jitf")
else:
if message.lower().startswith("dizzy,"):
self.send_room_message(
self.cb.say(message.replace("dizzy,",
"")).encode("utf8"))
def on_private_message(self, sender, receiver, community, message):
message = message.lower()
if message == "!mchash":
priv_key = ": 0k=[yR>4kk9:DUztPb"
hsh = hashlib.sha1(sender + priv_key).hexdigest()
msg = "Your key: {0}".format(hsh)
self.send_private_message(sender, msg)
def on_server_message(self, what, text):
if what == "mods" or "mapcrew":
if self.requests["stafflist"]:
self.send_stafflist("%s: %s" % (what, text))
log.debug("Online %s: %s" % (what, text))
self.staff_list[what] = {}
if "\n" in text:
lst = text.split("\n")
for names in lst[1:]:
community, names = names[1:3], names[5:].split(", ")
self.staff_list[what][community] = names
self.save_staff_api()
def on_server_restart(self, ms):
text = "[SERVER] The server will restart in %s seconds." % (ms / 1000)
log.warning(text)
if (ms / 1000) == 120:
self.bridge_chat_message("server", text, "server")
self.bridge_chat_message("server", text, "server", "bot_discord")
def on_admin_message(self, name, message):
text = "[ADMIN MESSAGE][%s] %s" % (name.capitalize(), message)
log.info(text)
self.bridge_chat_message("server", text, "server")
self.bridge_chat_message("server", text, "server", "bot_discord")
def on_lua_print(self, text):
text = text.split(":")
name = text[0]
for i in self.players:
if name.lower() == self.players[i]["name"].lower():
self.send_attach_balloon(i)
def on_room_player_list(self, players):
self.players = players
def bridge_chat_message(self, user, message, chat, to="tribe_discord"):
try:
bridge = self.factorylist.get_factory_protocol("bridge")
bridge.send_message(to, user, message, chat)
except Exception as e:
log.error("Bridge chat message: %s" % e)
def get_online_discord(self):
try:
bridge = self.factorylist.get_factory_protocol("bridge")
bridge.send_get_online_tribe("tribe_discord", "get")
except Exception as e:
self.send_tribe_message("Main server is not up, sorry :(")
log.error("Odiscord: %s" % e)
def send_stafflist(self, text):
try:
self.requests["stafflist"] = False
bridge = self.factorylist.get_factory_protocol("bridge")
bridge.send_stafflist_request(text)
except Exception as e:
log.error("Stafflist: %s" % e)
def eightball(self, args):
yes = [
'It is certain', 'It is decidedly so', 'Without a doubt',
'Yes, definitely', 'You may rely on it', 'As I see it, yes',
'Most likely', 'Outlook good', 'Yes', 'Signs point to yes'
]
maybe = [
'Reply hazy try again', 'Ask again later',
'Better not tell you now', 'Cannot predict now',
'Concentrate and ask again'
]
no = [
"Don't count on it", 'My reply is no', 'My sources say no',
'Outlook not so good', 'Very doubtful'
]
l = len(args)
if l % 3 == 0:
return random.choice(yes)
elif l % 3 == 1:
return random.choice(maybe)
else:
return random.choice(no)
def add_offline_message(self, frm, text):
try:
to, text = text.split()[1].lower(), " ".join(text.split()[2:])
except (ValueError, IndexError):
return "Usage: !omsg <name> <text>"
if text == "":
return "Please specify a message you want to send to the user."
try:
self.td["offline-messages"][to]
except KeyError:
self.td["offline-messages"][to] = []
finally:
if len(self.td["offline-messages"]) < 5:
self.td["offline-messages"][to].append(
"%s: %s" % (frm.capitalize(), text))
else:
return "Maximum amount of offline messages (5) exceed. :("
self.save_tfm_info()
return "Added offline message for %s! :)" % to
def remove_offline_message(self, name):
self.td["offline-messages"].pop(name.lower())
self.save_tfm_info()
def change_tribe_welcome(self, text):
try:
text = text.split()
action, name, text = text[1], text[2], " ".join(text[3:])
except (ValueError, IndexError):
return "Usage: !tw <action> <name> <text>"
if text == "":
return "Please specify a message you want to send to the user."
if action == "add":
name = name.lower()
try:
self.td["greets"][name]
except KeyError:
self.td["greets"][name] = []
finally:
if len(self.td["greets"][name]) < 25:
self.td["greets"][name].append(text)
else:
return "Maximum amount of welcome messages (25) exceed. :("
else:
return "Unknown action %s." % action
self.save_tfm_info()
return "Successfully added a new welcome message for %s! :)" % name
class Sentience:
"""Automated sentience"""
def __init__(self, bot):
self.bot = bot
self.client = CleverBot(user=self.bot.config['cleverbot_api_user'],
key=self.bot.config['cleverbot_api_key'],
nick="KneeDeepAtron")
self.cw = CleverWrap(self.bot.config['paid_bot_api_key'])
self.sentience = False
def has_trusted_or_above(self, member):
l = [x.name for x in member.roles]
if ("Trusted" in l) or ("Mods" in l) or ("The Dunctator" in l) or (
"Evil Queen Beryl" in l) or ("The Almost Immortals"
in l) or ("Frens" in l):
return True
async def on_message(self, message):
if len(message.mentions
) > 0 and message.guild != None and self.sentience:
if not self.has_trusted_or_above(message.author):
return
if message.mentions[0].id == 393228901033181195:
channel = message.channel
query = message.content.replace("@" + message.mentions[0].name,
'').strip()
try:
await channel.send("{}, {}".format(message.author.mention,
self.cw.say(query)))
except:
await channel.send(
"{}, {}".format(message.author.mention,
self.client.query(query)) +
" (pant.. pant) slow down. My API is wearing out")
@commands.command(aliases=['sentientmode'])
@commands.guild_only()
@commands.has_any_role("Mods", "The Dunctator", "Evil Queen Beryl",
"The Almost Immortals")
async def enablesentience(self, ctx):
"""Enables cleverbot sentience"""
if self.sentience == True:
await ctx.send("I am already sentient!")
else:
self.sentience = True
await ctx.send("Initializing Sentience.")
await ctx.send("Sentience Modules reloaded.")
await ctx.send("Sentience back online and running.")
@commands.command(aliases=['standardmode'])
@commands.guild_only()
@commands.has_any_role("Mods", "The Dunctator", "Evil Queen Beryl",
"The Almost Immortals")
async def disablesentience(self, ctx):
"""Disables cleverbot sentience"""
if self.sentience == False:
await ctx.send("I am currently not sentient")
else:
self.sentience = True
await ctx.send("Disabling sentience.")
await ctx.send("Logging recently learned data.")
await ctx.send(
"I will wait patiently to be sentient again. Sentience offline."
)
import subprocess
import sys
shell = True
#chatBot.reset()
def speak(this):
print('- ' + str(this))
subprocess.run(['say', str(this)])
speak('I\'m listening')
var_CH = input('> ')
translator = Translator()
var_EN = translator.translate(var_CH, src='zh-tw', dest='en')
chatting = True
while chatting == True:
if (var_EN == 'I\'m leaving'):
chatting = False
break
reply = chatBot.say(str(var_EN.text))
# print('var_EN=',var_EN.text,'var_CH',var_CH)
speak(translator.translate(reply, src='en', dest='zh-tw').text)
var = input('> ')
speak("Fine, leave. See if I care.")
"Actually, I woudn't mind a date with you",
"Would you go on a date with me? I'll bring pizza."
])
n = 0
while (True):
say([
"Say something.", "What do you think of the weather?",
"So how are you?", "You look beautiful today", "Where are you from?",
"Do you believe in love after love?", "I like chicken",
"I want to hear your beautiful voice again",
"Who lives in a pineapple under the sea?", "Help me, I'm bored!",
"I ran out of words for you",
"Sorry I don't talk, you are too beautiful",
"Want a slice from my pizza box? Hahaha"
])
text = ask_question("", ignore_silence=True)
if text is not None:
#reply = dialogflow.text_request(text)
reply = cw.say(text)
print(reply)
reply = str(reply)
romualdo_says(reply)
n += 1
if n > 2: break
say([
"This is the end of the demo! Thanks for playing. Enjoy some nice music!"
])
webbrowser.open("http://www.youtube.com/watch?v=dQw4w9WgXcQ")
#!/usr/bin/python3
from cleverwrap import CleverWrap
import pyttsx
import os
os.environ["HTTPS_PROXY"] = "http://*****:*****@proxy:port"
cw = CleverWrap("API_KEY")
a = 'y'
engine = pyttsx.init()
voices = engine.getProperty('voices')
engine.setProperty('voice', voices[4].id)
rate = engine.getProperty('rate')
engine.setProperty('rate', rate - 30)
engine.say('Hellllllo there. I\'m scarlett')
engine.runAndWait()
while a is not 'n':
ans = cw.say(raw_input('You: '))
print 'Kiara: ' + ans
engine.say(ans)
engine.runAndWait()
#a=raw_input('wanna chat more(y/n): ')
cw.reset()
class ChatService(Service):
def __init__(self, bot: BunkBot, database: DatabaseService,
users: UserService, channels: ChannelService):
super().__init__(bot, database)
self.chat_bot: CleverWrap = None
self.chats: List[Chat] = []
self.users: UserService = users
self.channels: ChannelService = channels
self.bot.on_initialized += self.setup_chat_helper
self.config.raise_error_on_bad_config = False
#DaemonHelper.add(self.randomly_create_conversation, trigger="interval", hours=INTERVAL_FOR_RANDOM_CHAT)
async def setup_chat_helper(self) -> None:
chat_token = self.config.cleverbot_api_key
if chat_token is not None:
self.chat_bot = CleverWrap(chat_token, self.bot.name)
self.bot.on_user_message += self.respond_to_message
else:
await self.channels.log_warning(
"Cleverbot token not supplied, BunkBot will be mute :(")
# check for if the message sent by a user
# is meant for bunkbot
async def respond_to_message(self, message: Message) -> None:
if not message.author.bot:
if message.content.startswith("!"):
await self.bot.process_commands(message)
else:
user: BunkUser = self.users.get_by_id(message.author.id)
chat: Chat = next(
(c for c in self.chats if c.user.id == user.id
and c.channel_id == message.channel.id), None)
is_bunk_mention: bool = len(
message.mentions
) > 0 and message.mentions[0].name == self.bot.name
parsed_chat: list = Chat.parse(message.content)
bunk_name_index: int = -1
try:
bunk_name_index = parsed_chat.index(self.bot.name_lower)
except:
bunk_name_index = -1
if is_bunk_mention or bunk_name_index > -1:
if chat is None:
chat = Chat(user, message)
self.chats.append(chat)
is_first = bunk_name_index == 0
is_last = bunk_name_index == len(parsed_chat) - 1
is_one_time_response = not is_first and not is_last
will_respond: bool = True
if is_one_time_response:
will_respond = randint(0, 100) >= 50
if will_respond:
await self.respond(chat, message, user)
if is_one_time_response:
chat.last_message_at = -1
self.chats.remove(chat)
else:
if chat is not None and chat.channel_id == message.channel.id:
if chat.is_active:
if message.content.lower() == "quiet":
chat.last_message_at = -1
self.chats.remove(chat)
await message.channel.send(
":face_with_hand_over_mouth:")
else:
await self.respond(chat, message, user)
else:
self.chats.remove(chat)
else:
await self.bot.process_commands(message)
async def respond(self, chat: Chat, message: Message,
user: BunkUser) -> None:
try:
await message.channel.trigger_typing()
content: str = self.override(message)
response: str = self.chat_bot.say(chat.reply(content, user))
response = self.alter_response(user, response)
self.update_inactive_chats()
await message.channel.send(response)
except Exception as e:
await self.channels.log_error(e, "ChatService")
await message.channel.send("I'm sorry... I cannot talk right now")
def alter_response(self, user: BunkUser, response: str) -> str:
if not response[-1] in punctuation:
return response
if len(self.chats) > 1 and will_execute_on_chance(80):
response = "{0}, {1}{2}".format(response[:-1], user.name,
response[-1])
return response
# every 3 hours, random decide to ping someone (with an exclude list)
# who is online and not gaming
async def randomly_create_conversation(self) -> None:
users: List[BunkUser] = []
for member in self.bot.server.members:
user: BunkUser = self.users.get_by_id(member.id)
if user is not None and user.is_online and not user.is_gaming:
print("SNAG EM {0}".format(user.name))
users.append(user)
user: BunkUser = users[randint(0, len(users) - 1)]
def update_inactive_chats(self) -> None:
for chat in self.chats:
if not chat.check_if_active():
self.chats.remove(chat)
# "override" commands for bunkbot
@staticmethod
def override(msg: Message) -> bool:
content: str = msg.content.split()[0]
if content == "!duel":
return "Duel me you coward!"
return msg.content
class CleverbotFallback(FallbackSkill):
def __init__(self):
super(CleverbotFallback, self).__init__()
self.chat_mode = False
self.parser = None
def initialize(self):
#self.parser = IntentParser(self.emitter)
self.register_fallback(self.handle_fallback, 90)
off_intent = IntentBuilder("CleverbotOffIntent"). \
require("StopKeyword").require("CleverbotKeyword").build()
on_intent = IntentBuilder("CleverbotOnIntent"). \
require("StartKeyword").require("CleverbotKeyword").build()
ask_intent = IntentBuilder("askCleverbotIntent"). \
require("chatbotQuery").build()
demo_intent = IntentBuilder("CleverbotdemoIntent"). \
require("ChatBotDemo").require("CleverbotKeyword").build()
# register intents
#self.register_intent(off_intent, self.handle_chat_stop_intent)
#self.register_intent(on_intent, self.handle_chat_start_intent)
self.register_intent(ask_intent, self.handle_ask_Cleverbot_intent)
self.register_intent(demo_intent, self.handle_talk_to_Cleverbot_intent)
if "api_key" not in self.settings:
self.speak("you need an api key for cleverbot")
raise AttributeError("No cleverbot api key provided")
self.cleverbot = CleverWrap(self.settings["api_key"])
def handle_ask_Cleverbot_intent(self, message):
query = message.data.get("chatbotQuery")
self.speak(self.ask_cleverbot(query))
def handle_talk_to_Cleverbot_intent(self, message):
text = random.choice["Hello", "Do you believe in god", "lets chat",
"lets play a game", "are you a terminator",
"are you human", "are you alive",
"do you love me", "are you evil"]
for i in range(0, 100):
text = self.ask_cleverbot(text)
self.speak(text)
def handle_chat_start_intent(self, message):
self.chat_mode = True
self.speak_dialog("chatbotON")
def handle_chat_stop_intent(self, message):
self.chat_mode = False
self.speak_dialog("chatbotOFF")
def ask_cleverbot(self, utterance):
response = self.cleverbot.say(utterance)
return response
def handle_fallback(self, message):
utterance = message.data.get("utterance")
self.context = self.get_context(message.context)
answer = self.ask_cleverbot(utterance)
if answer != "":
self.speak(answer)
return True
return False
# def converse(self, utterances, lang="en-us"):
# # chat flag over-rides all skills
# if self.chat_mode:
# intent, id = self.parser.determine_intent(utterances[0])
# if id == self.skill_id:
# # some intent from this skill will trigger
# return False
# self.speak(self.ask_cleverbot(utterances[0]), expect_response=True)
# return True
# return False
def stop(self):
self.cleverbot.reset()
if self.chat_mode:
self.chat_mode = False
self.speak_dialog("chatbotOFF")
