def receive():
bot = Bot()
content = request.json
response = bot.receive_message(content["id"], content["name"],
content["answer"])
return response
def __init__(self):
self.whatsapp = None
self.bot = Bot()
self.log_web = []
self.log_info = {}
self.init()
def decorate(bot: Bot):
bot.like_bot = True
res = raw_res = func(bot)
if res:
if type(res) is tuple and len(res) == 2:
bot.like_bot = bool(res[1])
res = res[0]
elif res and bot.BotReturns in getattr(res, "__bases__", []):
if res == bot.StopBot:
raise bot.StopBot
bot.send_feedback(res, bot.like_bot)
return raw_res
def set_players(self, color_current_user):
self.player1 = Player(color_current_user, True)
color_player2 = 'white' if color_current_user == 'black' else 'black'
if not self.with_bot:
self.player2 = Player(color_player2)
else:
self.player2 = Bot(color_player2)
def prompt():
questions = [
inquirer.Text(name="ads_id",
message="Elanın İD nömrəsini yazın",
validate=lambda _, x: str(x).isnumeric())
]
answers = inquirer.prompt(questions)
try:
crawler = Crawler(answers['ads_id'])
info = crawler.get_info()
bot = Bot(info)
bot.send()
except Exception as err:
print(err)
def event(cls, event: vk_api.longpoll.Event, api):
if event.type in Method.methods_by_code:
return [
method.func(Bot(api, event)) for method in filter(
lambda m: type(m.func) == func_type and
(Permission.have_access(m.permission, event.user_id) or
event.from_me) and m.req(event), Method.methods_by_code[
event.type])
]
return []
def main():
cfg_name = "lurch"
cfg = Config(cfg_name)
c = Connection(cfg.server)
wtf = WtfPlugin(c, cfg)
remind = RemindPlugin(c, cfg)
m = Magic8Plugin(c, cfg)
u = UrbanPlugin(c, cfg)
b = Bot(c, cfg.nick, cfg.channel, cfg.real, cfg.password)
b.install(wtf)
b.install(remind)
b.install(m)
b.install(u)
try:
b.run()
except KeyboardInterrupt:
c.disconnect()
def main():
sync = Sync()
service = Service()
scrapper = Scrapper()
cadastros = sync.carrega_todos_os_cadastros()
for cadastro in cadastros:
# Busca e atualiza o preço médio do boardgame
service_result = service.busca_preco_medio(cadastro['boardgame'])
sync.atualiza_preco_medio(cadastro, service_result['preco'])
if not service_result['preco']:
continue
# Faz o scrap no ludopedia para buscar anúncios deste produto
resultado_scrapper = scrapper.scrap_anuncios(cadastro['boardgame'])
# Compara os preços para ver se precisa ou não notificar o usuário
itens_para_notificar = filtra_itens_abaixo_do_preco(
service_result['preco'], resultado_scrapper)
if len(itens_para_notificar) == 0:
continue
bot = Bot()
for item in itens_para_notificar:
mensagem = (
"** ITEM ABAIXO DO PREÇO **\n\n"
f"O item '{cadastro['boardgame'].upper()}' possui preço médio de R$ {service_result['preco']}\n"
f"Encontramos o(s) seguinte(s) anúncio(s) abaixo do preço médio:\n"
"- Categoria: {}\n- Preço: {}\n- Link: {}".format(
item.get('category'),
item.get('value'),
item.get('link')
)
)
bot.enviar_notificacao(cadastro['chat_id'], mensagem)
def start(self):
while True:
print(Bot().dispatcher.get_me())
sleep(1)
class WorkerBot:
def __init__(self):
self.whatsapp = None
self.bot = Bot()
self.log_web = []
self.log_info = {}
self.init()
def init(self):
self.whatsapp = WhatsappApi()
self.bot.restart()
self.log_web = []
self.log_info = {}
clear_log()
def run(self):
set_forever()
while get_keep_running():
for message in self.whatsapp.get_messages(restart_index=True):
chat_id = message["chatId"]
name = message["senderName"]
text = message["body"]
tt = text
if "media/" in tt:
tt = f'<a href="{tt}">{tt}</a>'
self.add_log_web(f'Answer "{tt}" received from {name}')
self.add_log_info(chat_id, name, text, is_question=False)
question = self.bot.receive_message(chat_id, name, text)
response = self.whatsapp.send_message(chat_id, question)
self.add_log_web(f'Question "{question}" sent to {name}')
self.add_log_info(chat_id, name, question)
self.bot.export_results()
self.restart()
def add_log_web(self, text):
print(text)
self.log_web.append(text)
file = open(FILE_LOG_WEB, 'w')
json.dump(self.log_web, file)
def add_log_info(self, chat_id, name, text, is_question=True):
if chat_id in self.log_info:
if is_question:
self.log_info[chat_id]["questions"].append(text)
else:
self.log_info[chat_id]["answers"].append(text)
else:
self.log_info[chat_id] = {
"name": name,
"text": text,
"questions": [],
"answers": []
}
file = open(FILE_LOG_INFO, 'w')
json.dump(self.log_info, file)
def restart(self):
f = open(FILE_FOREVER, "w")
f.write("0")
f.close()
self.init()
set_forever()
self.run()
from modules.bot import Bot
if __name__ == '__main__':
bot = Bot()
bot.set_webhook()
def main():
telegram_bot = Bot()
telegram_bot.listen()
def main():
bot = Bot()
bot.run()
def __init__(self):
# create default personalities
cm = Character_Manager()
cm.save("character_default")
cm.save("character_stable")
cm.save("character_empathetic")
cm.save("character_irascible")
# set up logging
logging.basicConfig(
level=logging.INFO,
filename='../logs/app.log',
filemode="w",
format='%(asctime)s %(name)s/%(levelname)s - - %(message)s',
datefmt='%d.%m.%y %H:%M:%S')
self.logger = logging.getLogger("controller")
self.logger.setLevel(logging.INFO)
# read config file and save values in variables
self.config = configparser.ConfigParser()
self.config.read("../config/config.ini")
self.botname = self.config.get("default", "botname")
self.username = self.config.get("default", "username")
self.classifier_data = [
self.config.get("net", "classifier_type"),
self.config.get("net", "dataset"),
self.config.get("net", "feature_set")
]
self.logger.info("Conifg loaded: {}, {}, {}".format(
self.botname, self.username, self.classifier_data))
# initialize emotional variables
self.lex_happiness = pd.read_csv("../lexica/clean_happiness.csv",
delimiter=",",
dtype={
"text": str,
"affect": str,
"stems": str
},
float_precision='round_trip')
self.lex_sadness = pd.read_csv("../lexica/clean_sadness.csv",
delimiter=",",
dtype={
"text": str,
"affect": str,
"stems": str
},
float_precision='round_trip')
self.lex_anger = pd.read_csv("../lexica/clean_anger.csv",
delimiter=",",
dtype={
"text": str,
"affect": str,
"stems": str
},
float_precision='round_trip')
self.lex_fear = pd.read_csv("../lexica/clean_fear.csv",
delimiter=",",
dtype={
"text": str,
"affect": str,
"stems": str
},
float_precision='round_trip')
self.LIST_OF_LEXICA = self.lex_happiness, self.lex_sadness, self.lex_anger, self.lex_fear
self.list_happiness = self.lex_happiness["stems"].tolist()
self.list_sadness = self.lex_sadness["stems"].tolist()
self.list_anger = pd.Series(self.lex_anger["stems"].tolist())
self.list_fear = self.lex_fear["stems"].tolist()
self.lex_happiness_adj = pd.read_csv(
"../lexica/clean_happiness_adj.csv",
delimiter=",",
dtype={
"text": str,
"intensity": float
},
float_precision='round_trip')
self.lex_sadness_adj = pd.read_csv("../lexica/clean_happiness_adj.csv",
delimiter=",",
dtype={
"text": str,
"intensity": float
},
float_precision='round_trip')
self.lex_anger_adj = pd.read_csv("../lexica/clean_happiness_adj.csv",
delimiter=",",
dtype={
"text": str,
"intensity": float
},
float_precision='round_trip')
self.lex_fear_adj = pd.read_csv("../lexica/clean_happiness_adj.csv",
delimiter=",",
dtype={
"text": str,
"intensity": float
},
float_precision='round_trip')
self.logger.info("Lexica loaded")
# initialize ml-variables
if self.config.getboolean("default", "firstlaunch"):
# das md-model ist ca 80mb, das lg ca 1g
# self.nlp = spacy.load("en_core_web_lg")
self.nlp = spacy.load("en_core_web_md")
else:
self.nlp = spacy.load("../models/spacy")
self.spell = SpellChecker()
# create bot, responsible for generating answers and classifier, for analysing the input
self.character = Character(
self.config.getboolean("default", "firstlaunch"))
self.classifier = Classifier(self.classifier_data, self.LIST_OF_LEXICA,
self.nlp)
self.bot = Bot(self.lex_happiness, self.lex_sadness, self.lex_anger,
self.lex_fear, self.list_happiness, self.list_sadness,
self.list_anger, self.list_fear, self.lex_happiness_adj,
self.lex_sadness_adj, self.lex_anger_adj,
self.lex_fear_adj, self.nlp)
if self.config.getboolean("default", "firstlaunch"): self.bot.train()
# create frame and update widgets with initial values
self.frame = Frame(self.botname, self.character.get_emotional_state(),
self.character.get_emotional_history())
self.frame.register_subscriber(self)
self.frame.show()
# save all session data after the frame is closed
self.save_session()
logging.shutdown()
class Controller:
def __init__(self):
# create default personalities
cm = Character_Manager()
cm.save("character_default")
cm.save("character_stable")
cm.save("character_empathetic")
cm.save("character_irascible")
# set up logging
logging.basicConfig(
level=logging.INFO,
filename='../logs/app.log',
filemode="w",
format='%(asctime)s %(name)s/%(levelname)s - - %(message)s',
datefmt='%d.%m.%y %H:%M:%S')
self.logger = logging.getLogger("controller")
self.logger.setLevel(logging.INFO)
# read config file and save values in variables
self.config = configparser.ConfigParser()
self.config.read("../config/config.ini")
self.botname = self.config.get("default", "botname")
self.username = self.config.get("default", "username")
self.classifier_data = [
self.config.get("net", "classifier_type"),
self.config.get("net", "dataset"),
self.config.get("net", "feature_set")
]
self.logger.info("Conifg loaded: {}, {}, {}".format(
self.botname, self.username, self.classifier_data))
# initialize emotional variables
self.lex_happiness = pd.read_csv("../lexica/clean_happiness.csv",
delimiter=",",
dtype={
"text": str,
"affect": str,
"stems": str
},
float_precision='round_trip')
self.lex_sadness = pd.read_csv("../lexica/clean_sadness.csv",
delimiter=",",
dtype={
"text": str,
"affect": str,
"stems": str
},
float_precision='round_trip')
self.lex_anger = pd.read_csv("../lexica/clean_anger.csv",
delimiter=",",
dtype={
"text": str,
"affect": str,
"stems": str
},
float_precision='round_trip')
self.lex_fear = pd.read_csv("../lexica/clean_fear.csv",
delimiter=",",
dtype={
"text": str,
"affect": str,
"stems": str
},
float_precision='round_trip')
self.LIST_OF_LEXICA = self.lex_happiness, self.lex_sadness, self.lex_anger, self.lex_fear
self.list_happiness = self.lex_happiness["stems"].tolist()
self.list_sadness = self.lex_sadness["stems"].tolist()
self.list_anger = pd.Series(self.lex_anger["stems"].tolist())
self.list_fear = self.lex_fear["stems"].tolist()
self.lex_happiness_adj = pd.read_csv(
"../lexica/clean_happiness_adj.csv",
delimiter=",",
dtype={
"text": str,
"intensity": float
},
float_precision='round_trip')
self.lex_sadness_adj = pd.read_csv("../lexica/clean_happiness_adj.csv",
delimiter=",",
dtype={
"text": str,
"intensity": float
},
float_precision='round_trip')
self.lex_anger_adj = pd.read_csv("../lexica/clean_happiness_adj.csv",
delimiter=",",
dtype={
"text": str,
"intensity": float
},
float_precision='round_trip')
self.lex_fear_adj = pd.read_csv("../lexica/clean_happiness_adj.csv",
delimiter=",",
dtype={
"text": str,
"intensity": float
},
float_precision='round_trip')
self.logger.info("Lexica loaded")
# initialize ml-variables
if self.config.getboolean("default", "firstlaunch"):
# das md-model ist ca 80mb, das lg ca 1g
# self.nlp = spacy.load("en_core_web_lg")
self.nlp = spacy.load("en_core_web_md")
else:
self.nlp = spacy.load("../models/spacy")
self.spell = SpellChecker()
# create bot, responsible for generating answers and classifier, for analysing the input
self.character = Character(
self.config.getboolean("default", "firstlaunch"))
self.classifier = Classifier(self.classifier_data, self.LIST_OF_LEXICA,
self.nlp)
self.bot = Bot(self.lex_happiness, self.lex_sadness, self.lex_anger,
self.lex_fear, self.list_happiness, self.list_sadness,
self.list_anger, self.list_fear, self.lex_happiness_adj,
self.lex_sadness_adj, self.lex_anger_adj,
self.lex_fear_adj, self.nlp)
if self.config.getboolean("default", "firstlaunch"): self.bot.train()
# create frame and update widgets with initial values
self.frame = Frame(self.botname, self.character.get_emotional_state(),
self.character.get_emotional_history())
self.frame.register_subscriber(self)
self.frame.show()
# save all session data after the frame is closed
self.save_session()
logging.shutdown()
# takes the users intent (per gui interaction) and starts the corresponding methods
def handle_intent(self,
intent,
input_message=None,
character=None,
classifier_type=None,
dataset=None,
feature_set=None):
if intent == "load_character":
self.character.load(character)
self.frame.update_diagrams(self.character.get_emotional_state(),
self.character.get_emotional_history())
self.frame.update_log(
[{
"character ready": self.character.character_name
}],
clear=True)
elif intent == "get_response":
if input_message and input_message != "":
self.handle_input(input_message)
elif intent == "retrain_bot":
self.bot.train()
self.frame.update_log(["chatbot training completed"], clear=True)
elif intent == "reset_state":
self.character.reset_bot()
self.frame.update_diagrams(self.character.get_emotional_state(),
self.character.get_emotional_history())
self.frame.update_log(["chatbot internal state reset"], clear=True)
elif intent == "change_classifier":
self.classifier_data = [classifier_type, dataset, feature_set]
self.classifier.load_network(self.classifier_data)
self.frame.update_log([{
"classifier ready": self.classifier_data
}],
clear=True)
self.logger.info("classifier loaded: {}".format(" ".join(
self.classifier_data)))
# take user input, generate new data an update ui
def handle_input(self, user_input):
# user_input = self.correct_input(user_input)
# update all modules
response_package = self.bot.respond(user_input)
ml_package = self.classifier.get_emotions(user_input)
state_package = self.character.update_emotional_state(
ml_package.get("input_emotions"))
response_package = self.bot.modify_output(
response_package, state_package["highest_emotion"],
state_package["highest_score"])
# update gui
self.frame.update_chat_out(user_input,
response_package.get("response").__str__(),
self.botname, self.username)
self.frame.update_log([{
"classifier": " ".join(self.classifier_data),
"character": self.character.character_name
}, ml_package, state_package])
self.frame.update_diagrams(state_package.get("emotional_state"),
state_package.get("emotional_history"))
# corrects user input
def correct_input(self, user_input):
# make list of all words
words = user_input.split(" ")
unknown_words = self.spell.unknown(words)
# replace all unknown words
for word in unknown_words:
print("correction: ", word, self.spell.correction(word))
user_input = user_input.replace(word, self.spell.correction(word))
return user_input
# handles saving data when closing the program
def save_session(self):
# saves current character state
self.character.save()
# set the first launch variable to false
self.config.set("default", "firstlaunch", "NO")
self.config.set("net", "classifier_type", self.classifier_data[0])
self.config.set("net", "dataset", self.classifier_data[1])
self.config.set("net", "feature_set", self.classifier_data[2])
# save nlp model
print("saving spacy")
self.nlp.to_disk("../models/spacy")
# save new value in file
with open("../config/config.ini", "w") as f:
self.config.write(f)
self.logger.info(f"Session saved - end program")
def restart():
bot = Bot()
bot.restart()
return 'restarted'
if __name__=='__main__':
if sys.version_info[:2]<(3,6):
print('You need at least Python3.6 to run this program.')
sys.exit(1)
supported_browsers=['chrome','firefox']
parser=ArgumentParser()
parser.add_argument('-u','--url',help='Set URL | Set path to URL list',metavar='URL|FILE')
parser.add_argument('-p','--processes',default=15,type=int,help='Set number of processes',metavar='N')
parser.add_argument('-B','--browser',choices=supported_browsers,help='Set browser',metavar='BROWSER')
parser.add_argument('-P','--proxies',help='Set path to proxy list',metavar='FILE')
parser.add_argument('-R','--referer',help='Set referer | Set path to referer list',metavar='REFERER|FILE')
parser.add_argument('-U','--user-agent',help='Set user agent | Set path to user agent list',metavar='USER_AGENT|FILE')
args=parser.parse_args()
urls=URLs(args.url or Input.get('URL'))
browser=args.browser or Input.select('Browser',supported_browsers)
print('Click ENTER to use default value.')
proxies=Proxies(Input.get('Proxies') or args.proxies)
referers=Referers(Input.get('Referers') or args.referer)
user_agents=UserAgents(Input.get('User agents') or args.user_agent)
executable_path=WebDriver.install_if_not_installed(browser)
extension_path=Extension.install_if_not_installed(browser)
processes=[Process(target=Bot().run,args=(urls,browser,proxies,referers,user_agents,executable_path,extension_path),daemon=True) for _ in range(args.processes)]
for process in processes:
process.start()
signal.signal(signal.SIGINT,signal.SIG_IGN)
for process in processes:
process.join()
if WebDriver.system=='Windows':
os.system(f'taskkill /IM {browser}.exe /T /F >NUL 2>&1')
sys.exit(0)
def export():
bot = Bot()
bot.export_results()
return 'exported'
