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()
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 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 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}")
import random
import time
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))
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 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")
#!/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()