class chatbot

import nltk
import numpy as np
import random
import string # to process standard python strings
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity

class Learner():
    def learning(self, file):
        f=open(file,'r',errors = 'ignore')
        raw=f.read()
        raw=raw.lower()# converts to lowercase
        #nltk.download('punkt') # first-time use only
        #nltk.download('wordnet') # first-time use only
        self.sent_tokens = nltk.sent_tokenize(raw)# converts to list of sentences
        self.word_tokens = nltk.word_tokenize(raw)# converts to list of wordscd
        self.lemmer = nltk.stem.WordNetLemmatizer()
        #WordNet is a semantically-oriented dictionary of English included in NLTK.

class Chatbots():

    def __init__(self, sent_tokens, word_tokens,lemmer, greeting_inputs,greeting_responses):
        self.sent_tokens = sent_tokens
        self.scword_tokenshool = word_tokens
        self.lemmer = lemmer
        self.remove_punct_dict = dict((ord(punct), None) for punct in string.punctuation)
        self.greeting_inputs = greeting_inputs
        self.greeting_responses = greeting_responses

    def LemTokens(self,tokens):
        return [self.lemmer.lemmatize(token) for token in tokens]

    #remove_punct_dict = dict((ord(punct), None) for punct in string.punctuation)
    def LemNormalize(self,texto):
        return LemTokens(nltk.word_tokenize(text.lower().translate(self.remove_punct_dict)))

    def greeting(self,sentence):
        for word in sentence.split():
            if word.lower() in self.greeting_inputs:
                return random.choice(self.greeting_responses)


    def response(self,user_response):
        robo_response=''
        self.sent_tokens.append(user_response)
        TfidfVec = TfidfVectorizer(tokenizer=LemNormalize, stop_words='english')
        tfidf = TfidfVec.fit_transform(self.sent_tokens)
        vals = cosine_similarity(tfidf[-1], tfidf)
        idx=vals.argsort()[0][-2]
        flat = vals.flatten()
        flat.sort()
        req_tfidf = flat[-2]
        if(req_tfidf==0):
            robo_response=robo_response+"I am sorry! I don't understand you"
            return robo_response
        else:
            robo_response = robo_response+self.sent_tokens[idx]
            return robo_response

    def conversation(self,word):
        print("ROBO: My name is Robo. I will answer your queries about Chatbots. If you want to exit, type Bye!")
        flag=True
        while(flag==True):
            user_response = word
            user_response=user_response.lower()
            if(user_response!='bye'):
                if(user_response=='thanks' or user_response=='thank you' ):
                    flag=False
                    print("ROBO: You are welcome..")
                else:
                    if(chatbot.greeting(user_response)!=None):
                        print("ROBO: "+chatbot.greeting(user_response))
                    else:
                        print("ROBO: ",end="")
                        print(response(user_response))
                        self.sent_tokens.remove(user_response)
            else:
                flag=False
                print("ROBO: Bye! take care..")





rute = "Phyton\\Udemy\\Javier Sossa IA\\chatbot.txt"
learn = Learner()
learn.learning(rute)

GREETING_INPUTS = ("hello", "hi", "greetings", "sup", "what's up","hey",)
GREETING_RESPONSES = ["hi", "hey", "*nods*", "hi there", "hello", "I am glad! You are talking to me"]

chatbot = Chatbots(learn.sent_tokens,learn.word_tokens,learn.lemmer,GREETING_INPUTS,GREETING_RESPONSES)
chatbot.conversation("hey")