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
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()
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
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 :(")
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 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 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 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()
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 :(")
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 __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 __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)
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 _init_cleverbot(self, tid):
with self.cleverbots_lock:
if tid in self.cleverbots:
return self.cleverbots[tid]
cleverbot = CleverWrap(self.cleverbot_token)
self.cleverbots[tid] = cleverbot
return cleverbot
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 _get_cw_for_chat(bot, event):
"""initialise/get cleverbot api wrapper"""
# setting segregate to False makes cleverbot share its memory across non-segregated conversations
# important: be careful of information leaking from one conversation to another!
# by default, conversation memory is segregrated by instantiating new cleverwrap interfaces
segregate = bot.get_config_suboption(event.conv_id, "cleverbot_segregate")
if segregate is None:
segregate = True
if segregate:
index = event.conv_id
else:
index = "shared"
if index in __cleverbots:
return __cleverbots[index]
else:
# dev: you can define different API keys for different conversations
api_key = bot.get_config_suboption(event.conv_id, "cleverbot_api_key")
if not api_key:
return None
else:
cw = CleverWrap(api_key)
__cleverbots[index] = cw
logger.debug("created new cw for {}".format(index))
return cw
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
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 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}")
def connect_to_cleverbot():
"""
Connect to the Cleverbot API.
Returns:
CleverWrap: The connection to the Cleverbot API
"""
if CLEVERBOT_API_KEY_VAR in os.environ:
return CleverWrap(os.environ[CLEVERBOT_API_KEY_VAR])
raise EnvironmentError(
"\n\nNo cleverbot API key found. Please do the following to get up and running:"
"\n- Register a user at 'https://www.cleverbot.com/api/'"
"\n- Set the environment variable '{}' to the API key value given on your cleverbot api account page."
.format(CLEVERBOT_API_KEY_VAR))
def getTokens():
config = configparser.ConfigParser()
if not os.path.isfile("tokens.cfg"):
print("tokens file missing. ")
print("Creating one now.")
config.add_section("Tokens")
config.set("Tokens", "Bot", "null")
config.set("Tokens", "Cleverbot", "null")
with open('tokens.cfg', 'w') as configfile:
config.write(configfile)
print("File created.")
print("Please edit tokens.cfg and then restart.")
_ = input()
else:
config.read('tokens.cfg')
global botToken
botToken = config.get('Tokens', 'Bot')
global cb
cb = CleverWrap(config.get('Tokens', 'Cleverbot'))
from sqlalchemy import create_engine
from json import dumps
from flask.ext.jsonpify import jsonify
import apiai
import speech_recognition as sr
from cleverwrap import CleverWrap
import core as C
import modules as M
CLIENT_ACCESS_TOKEN = '0be9930a8de146deb3014346c5de1d9d'
#Instanciar API.AI
ai = apiai.ApiAI(CLIENT_ACCESS_TOKEN)
#Instanciar Cleverbot
cw = CleverWrap("CC1yyLsWicOuwBwEhMJigtOkixg")
AL = M.Analyzer()
app = Flask(__name__)
api = Api(app)
TOKENS = ['234234123123eddjhskdasa342', '1233543jkk4hkjdhsfhsas']
def APIAI_rec(texto):
request = ai.text_request()
request.lang = 'es' # Lenguaje
request.session_id = "_HOlaMundo_"
request.query = texto
response = request.getresponse()
def call_clever_bot(message, clever_bot_convo):
#url_params = {'input' : message, 'key' : CLEVERBOT_TOKEN}
try:
reply = clever_bot_convo.say(message)
return reply
except cleverbot.APIError as e:
print(e.error, e.status)
#main gatta be on the bottom. Code runs top to bottom. Functions need to be init'd first. For future notice (because Joey forgets things).
#------------------------------------------------------#
#Function: main
#Use: main processing of script
#Arguments: none
#Return: none
#------------------------------------------------------#
if __name__ == '__main__':
slack_client = SlackClient(SLACK_TOKEN)
cb = CleverWrap(CLEVERBOT_TOKEN)
convo = cb.conversation()
if (slack_client.rtm_connect()):
print("Marvin has connected sir. As if it matters.")
marvin_id = slack_client.api_call("auth.test")["user_id"]
while True:
command, channel = parse_command(slack_client.rtm_read())
if command:
handle_command(command, channel, convo)
time.sleep(READ_WEB_DELAY)
else:
print("RTM connection failure. Check Token dingleberry. DO IT AGAIN!")
#!/usr/bin/python
# -*- coding: utf-8 -*-
from cleverwrap import CleverWrap
cw = CleverWrap("")
from telegram.ext import Updater, CommandHandler, MessageHandler, Filters
# almacenamiento con sqlite
import datos as dts
import time
import logging
# Enable logging
logging.basicConfig(
filename='chatbot.log',
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
level=logging.INFO)
logger = logging.getLogger(__name__)
def start(bot, update):
update.message.reply_text("""\
Indico con precisión los mejores momentos para comprar y vender criptomonedas.
Si sigues mis consejos podrás comprar barato y vender caro.\
""")
time.sleep(6)
update.message.reply_text("O esa es la intención al menos.")
time.sleep(2)
update.message.reply_text("""\
def __init__(self, botName, apiKey):
print("Initiate Bot {}".format(botName))
CleverWrap.__init__(self, apiKey, botName)
with open("settings_testing.json", "rb") as f:
settings = json.load(f)
bot = commands.Bot(
command_prefix=["!"]) # testing bot only responds to !-prefixed cmds
else:
with open("settings.json", "rb") as f:
settings = json.load(f)
bot = commands.Bot(command_prefix=prefixes)
bot.buxman = Manager(bot)
bot.settings = settings
# bot.sesh = aiohttp.ClientSession(loop=bot.loop)
# this has been moved to an "async with" statement in the gelbooru cog so that the
# session is created inside an async function
cb = CleverWrap(settings["cleverbot_token"])
bot.last_chat = datetime.datetime.now(
) # to determine when to reset the cleverbot interaction
bot.cbchannels = settings["cleverbot_channels"]
with open("snektext.json", "r") as f:
bot.text = json.load(f)
def is_owner(ctx):
return ctx.message.author.id == bot.settings["owner_id"]
class NickFind():
"""This needs to appear like a compiled regex object with a findall method"""
@staticmethod
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
# This is a voice-output interface for CleverBot, a chatbot.
# Needs python3, cleverwrap and flite chattyto run
# python should be present in a unix terminal
#
# pip install cleverwrap
# sudo apt-get install flite
#
# Usage:
# python chatBot.py
# then just type after the > prompt
# to leave, type > I'm leaving
from googletrans import Translator
from cleverwrap import CleverWrap
chatBot = CleverWrap("CC6zkRgO9TPlPcz6AO_zLCunNBg")
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')
