import nltk
nltk.download('punkt')
nltk.download('wordnet')
from nltk.stem import WordNetLemmatizer
lemmatizer = WordNetLemmatizer()
import json
import pickle

import numpy as np
from keras.models import Sequential
from keras.layers import Dense, Activation, Dropout
from keras.optimizers import SGD
import random

words=[]
classes = []
documents = []
ignore_words = ['?', '!']
data_file = open('intents.json').read()
intents = json.loads(data_file)

for intent in intents['intents']:
    for pattern in intent['patterns']:

        # take each word and tokenize it
        w = nltk.word_tokenize(pattern)
        words.extend(w)
        # adding documents
        documents.append((w, intent['tag']))

        # adding classes to our class list
        if intent['tag'] not in classes:
            classes.append(intent['tag'])

words = [lemmatizer.lemmatize(w.lower()) for w in words if w not in ignore_words]
words = sorted(list(set(words)))

classes = sorted(list(set(classes)))

print (len(documents), "documents")

print (len(classes), "classes", classes)

print (len(words), "unique lemmatized words", words)


pickle.dump(words,open('words.pkl','wb'))
pickle.dump(classes,open('classes.pkl','wb'))

# initializing training data
training = []
output_empty = [0] * len(classes)
for doc in documents:
    # initializing bag of words
    bag = []
    # list of tokenized words for the pattern
    pattern_words = doc[0]
    # lemmatize each word - create base word, in attempt to represent related words
    pattern_words = [lemmatizer.lemmatize(word.lower()) for word in pattern_words]
    # create our bag of words array with 1, if word match found in current pattern
    for w in words:
        bag.append(1) if w in pattern_words else bag.append(0)

    # output is a '0' for each tag and '1' for current tag (for each pattern)
    output_row = list(output_empty)
    output_row[classes.index(doc[1])] = 1

    training.append([bag, output_row])
# shuffle our features and turn into np.array
random.shuffle(training)
training = np.array(training)
# create train and test lists. X - patterns, Y - intents
train_x = list(training[:,0])
train_y = list(training[:,1])
print("Training data created")

# Create model - 3 layers. First layer 128 neurons, second layer 64 neurons and 3rd output layer contains number of neurons
# equal to number of intents to predict output intent with softmax
model = Sequential()
model.add(Dense(128, input_shape=(len(train_x[0]),), activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(64, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(len(train_y[0]), activation='softmax'))

# Compile model. Stochastic gradient descent with Nesterov accelerated gradient gives good results for this model
sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['accuracy'])

#fitting and saving the model
hist = model.fit(np.array(train_x), np.array(train_y), epochs=200, batch_size=5, verbose=1)
model.save('chatbot_model.h5', hist)

print("model created")

from keras.models import load_model
model = load_model('chatbot_model.h5')
import json
import random
intents = json.loads(open('intents.json').read())
words = pickle.load(open('words.pkl','rb'))
classes = pickle.load(open('classes.pkl','rb'))

def clean_up_sentence(sentence):
    sentence_words = nltk.word_tokenize(sentence)
    sentence_words = [lemmatizer.lemmatize(word.lower()) for word in sentence_words]
    return sentence_words

# return bag of words array: 0 or 1 for each word in the bag that exists in the sentence

def bow(sentence, words, show_details=True):
    # tokenize the pattern
    sentence_words = clean_up_sentence(sentence)
    # bag of words - matrix of N words, vocabulary matrix
    bag = [0]*len(words)
    for s in sentence_words:
        for i,w in enumerate(words):
            if w == s:
                # assign 1 if current word is in the vocabulary position
                bag[i] = 1
                if show_details:
                    print ("found in bag: %s" % w)
    return(np.array(bag))

def predict_class(sentence, model):
    # filter out predictions below a threshold
    p = bow(sentence, words,show_details=False)
    res = model.predict(np.array([p]))[0]
    ERROR_THRESHOLD = 0.25
    results = [[i,r] for i,r in enumerate(res) if r>ERROR_THRESHOLD]
    # sort by strength of probability
    results.sort(key=lambda x: x[1], reverse=True)
    return_list = []
    for r in results:
        return_list.append({"intent": classes[r[0]], "probability": str(r[1])})
    return return_list

def getResponse(ints, intents_json):
    tag = ints[0]['intent']
    list_of_intents = intents_json['intents']
    for i in list_of_intents:
        if(i['tag']== tag):
            result = random.choice(i['responses'])
            break
    return result

def chatbot_response(msg):
    ints = predict_class(msg, model)
    res = getResponse(ints, intents)
    return res

#Creating GUI with tkinter
import tkinter
from tkinter import *


def send():
    msg = EntryBox.get("1.0",'end-1c').strip()
    EntryBox.delete("0.0",END)

    if msg != '':
        ChatLog.config(state=NORMAL)
        ChatLog.insert(END, "You: " + msg + '\n\n')
        ChatLog.config(foreground="#442265", font=("Verdana", 12 ))

        res = chatbot_response(msg)
        ChatLog.insert(END, "Bot: " + res + '\n\n')

        ChatLog.config(state=DISABLED)
        ChatLog.yview(END)


base = Tk()
base.title("Hello")
base.geometry("400x500")
base.resizable(width=FALSE, height=FALSE)

#Create Chat window
ChatLog = Text(base, bd=0, bg="white", height="8", width="50", font="Arial",)

ChatLog.config(state=DISABLED)

#Bind scrollbar to Chat window
scrollbar = Scrollbar(base, command=ChatLog.yview, cursor="heart")
ChatLog['yscrollcommand'] = scrollbar.set

#Create Button to send message
SendButton = Button(base, font=("Verdana",12,'bold'), text="Send", width="12", height=5,
                    bd=0, bg="#32de97", activebackground="#3c9d9b",fg='#ffffff',
                    command= send )

#Create the box to enter message
EntryBox = Text(base, bd=0, bg="white",width="29", height="5", font="Arial")
#EntryBox.bind("<Return>", send)


#Place all components on the screen
scrollbar.place(x=376,y=6, height=386)
ChatLog.place(x=6,y=6, height=386, width=370)
EntryBox.place(x=128, y=401, height=90, width=265)
SendButton.place(x=6, y=401, height=90)

base.mainloop()

from django.contrib.auth.models import User
from django.contrib.auth import authenticate, login, logout
from django.http import JsonResponse

def register(request):
    """
    用户注册
    """
    username = request.POST.get('username', '')
    password = request.POST.get('password', '')
    email = request.POST.get('email', '')
    if username and password and email:
        if User.objects.filter(username=username).exists():
            return JsonResponse({'code': 400, 'msg': '用户名已存在'})
        else:
            user = User.objects.create_user(username=username, email=email, password=password)
            user.save()
            return JsonResponse({'code': 200, 'msg': '注册成功'})
    else:
        return JsonResponse({'code': 400, 'msg': '参数错误'})

def user_login(request):
    """
    用户登录
    """
    username = request.POST.get('username', '')
    password = request.POST.get('password', '')
    user = authenticate(username=username, password=password)
    if user is not None:
        login(request, user)
        return JsonResponse({'code': 200, 'msg': '登录成功'})
    else:
        return JsonResponse({'code': 400, 'msg': '用户名或密码错误'})

def user_logout(request):
    """
    用户注销
    """
    logout(request)
    return JsonResponse({'code': 200, 'msg': '注销成功'})

def check_user(request):
    """
    检查用户是否存在
    """
    username = request.POST.get('username', '')
    if User.objects.filter(username=username).exists():
        return JsonResponse({'code': 200, 'msg': '用户存在'})
    else:
        return JsonResponse({'code': 400, 'msg': '用户不存在'})

import itchat
import jieba
import requests
from itchat.content import *
from django.http import JsonResponse

def get_weather(city):
    """
    获取天气信息
    """
    url = 'https://api.openweathermap.org/data/2.5/weather?q={}&appid={}'
    appid = 'your_appid'
    r = requests.get(url.format(city, appid))
    if r.status_code == 200:
        result = r.json()
        weather = result.get('weather', [])
        if weather:
            main = weather[0].get('main', '')
            description = weather[0].get('description', '')
            return '{}，{}'.format(main, description)
    return '获取天气信息失败'

def get_stock(code):
    """
    获取股票信息
    """
    url = 'http://hq.sinajs.cn/list={}'
    r = requests.get(url.format(code))
    if r.status_code == 200:
        result = r.text.split('"')[1]
        items = result.split(',')
        name = items[0]
        price = items[3]
        change = items[2]
        percent = (float(price) - float(change)) / float(change) * 100
        return '{}，现价{}，涨跌{}，涨跌幅{:.2f}%'.format(name, price, change, percent)
    return '获取股票信息失败'

@itchat.msg_register([TEXT, VOICE])
def text_reply(msg):
    """
    接收用户消息，解析用户意图，并回复用户消息
    """
    user = msg['User']
    content = msg['Text']
    if user['UserName'] != 'filehelper':
        if '天气' in content:
            city = content.split('天气')[0]
            result = get_weather(city)
        elif '股票' in content:
            code = content.split('股票')[0]
            result = get_stock(code)
        else:
            result = '我不知道你在说什么'
        itchat.send_msg(result, toUserName=user['UserName'])

        # 保存聊天记录
        History.objects.create(user=user['NickName'], content=content, reply=result)

        return JsonResponse({'code': 200, 'msg': '回复成功'})

from django.db import models

class History(models.Model):
    user = models.CharField(max_length=50)
    content = models.TextField()
    reply = models.TextField()
    create_time = models.DateTimeField(auto_now_add=True)

    class Meta:
        db_table = 'history'

    def __str__(self):
        return '{} {}: {}'.format(self.create_time.strftime('%Y-%m-%d %H:%M:%S'), self.user, self.content)

    @staticmethod
    def get_history(user):
        """
        获取历史聊天记录
        """
        history_list = History.objects.filter(user=user).order_by('-create_time')
        result = []
        for history in history_list:
            item = {
                'time': history.create_time.strftime('%Y-%m-%d %H:%M:%S'),
                'content': history.content,
                'reply': history.reply
            }
            result.append(item)
        return result

import os
from pathlib import Path

BASE_DIR = Path(__file__).resolve().parent.parent

SECRET_KEY = 'django-insecure-#9@#n&%&6^v@6=$1#6f&q_dwl(*bcz6g1#5u!^5=5@8#%&@a1%'

DEBUG = True

ALLOWED_HOSTS = ['*']

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'history',
]

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

ROOT_URLCONF = 'chatbot.urls'

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [BASE_DIR / 'templates'],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]

WSGI_APPLICATION = 'chatbot.wsgi.application'

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'chatbot',
        'USER': 'root',
        'PASSWORD': 'password',
        'HOST': 'mysql',
        'PORT': '3306',
        'OPTIONS': {
            'charset': 'utf8mb4',
        },
    }
}

AUTH_USER_MODEL = 'auth.User'

AUTHENTICATION_BACKENDS = [
    'django.contrib.auth.backends.ModelBackend',
]

LANGUAGE_CODE = 'zh-hans'

TIME_ZONE = 'Asia/Shanghai'

USE_I18N = True

USE_L10N = True

USE_TZ = False

STATIC_URL = '/static/'
STATIC_ROOT = BASE_DIR / 'static'

from django.shortcuts import render
from django.contrib.auth import authenticate, login, logout
from django.contrib.auth.decorators import login_required
from django.http import JsonResponse
from django.views.decorators.csrf import csrf_exempt
from django.contrib.auth.models import User
from history.models import History
import requests
import json

@csrf_exempt
def register(request):
    """
    用户注册
    """
    username = request.POST.get('username', '')
    password = request.POST.get('password', '')
    email = request.POST.get('email', '')
    if username and password and email:
        if User.objects.filter(username=username).exists():
            return JsonResponse({'code': 400, 'msg': '用户名已存在'})
        else:
            user = User.objects.create_user(username=username, email=email, password=password)
            user.save()
            return JsonResponse({'code': 200, 'msg': '注册成功'})
    else:
        return JsonResponse({'code': 400, 'msg': '参数错误'})

@csrf_exempt
def user_login(request):
    """
    用户登录
    """
    username = request.POST.get('username', '')
    password = request.POST.get('password', '')
    user = authenticate(username=username, password=password)
    if user is not None:
        login(request, user)
        return JsonResponse({'code': 200, 'msg': '登录成功'})
    else:
        return JsonResponse({'code': 400, 'msg': '用户名或密码错误'})

@login_required
def user_logout(request):
    """
    用户注销
    """
    logout(request)
    return JsonResponse({'code': 200, 'msg': '注销成功'})

@csrf_exempt
def check_user(request):
    """
    检查用户是否存在
    """
    username = request.POST.get('username', '')
    if User.objects.filter(username=username).exists():
        return JsonResponse({'code': 200, 'msg': '用户存在'})
    else:
        return JsonResponse({'code': 400, 'msg': '用户不存在'})

@login_required
def get_history(request):
    """
    获取历史聊天记录
    """
    user = request.user.username
    history_list = History.get_history(user)
    return JsonResponse({'code': 200, 'msg': '获取历史聊天记录成功', 'data': history_list})

@login_required
def chat(request):
    """
    聊天机器人
    """
    if request.method == 'GET':
        return render(request, 'chat.html')
    elif request.method == 'POST':
        content = request.POST.get('content', '')
        if content:
            user = request.user.username
            api_url = 'http://api.qingyunke.com/api.php?key=free&appid=0&msg=' + content
            response = requests.get(api_url)
            response.encoding = 'utf-8'
            result = json.loads(response.text)
            reply = result['content'].replace('{br}', '\n')
            # 保存聊天记录
            History.add_history(user, content, reply)
            return JsonResponse({'code': 200, 'msg': '获取聊天机器人回复成功', 'data': {'reply': reply}})
        else:
            return JsonResponse({'code': 400, 'msg': '参数错误'})

from django.db import models

class History(models.Model):
    user = models.CharField(max_length=50, verbose_name='用户')
    content = models.TextField(verbose_name='用户输入')
    reply = models.TextField(verbose_name='聊天机器人回复')
    create_time = models.DateTimeField(auto_now_add=True, verbose_name='创建时间')

    class Meta:
        verbose_name = '历史聊天记录'
        verbose_name_plural = verbose_name

    @staticmethod
    def add_history(user, content, reply):
        """
        添加聊天记录
        """
        history = History(user=user, content=content, reply=reply)
        history.save()

    @staticmethod
    def get_history(user):
        """
        获取历史聊天记录
        """
        history_list = History.objects.filter(user=user).order_by('-create_time').all()
        result_list = []
        for history in history_list:
            result_list.append({'content': history.content, 'reply': history.reply})
        return result_list


from django.urls import path
from . import views
urlpatterns = [
    path('register/', views.register, name='register'),
    path('login/', views.user_login, name='user_login'),
    path('logout/', views.user_logout, name='user_logout'),
    path('check_user/', views.check_user, name='check_user'),
    path('get_history/', views.get_history, name='get_history'),
    path('chat/', views.chat, name='chat'),
]

<template>
  <div class="app">
    <div class="login" v-if="!isLogin">
      <h1>聊天机器人</h1>
      <form @submit.prevent="login">
        <input type="text" v-model="username" placeholder="请输入用户名" required>
        <input type="password" v-model="password" placeholder="请输入密码" required>
        <button>登录</button>
      </form>
      <div class="register">
        <router-link to="/register">注册</router-link>
      </div>
    </div>
    <div class="chat" v-else>
      <div class="header">
        <h1>聊天机器人</h1>
        <div class="user-info">
          <img :src="'/static/img/' + userInfo.avatar" alt="">
          <span>{{ userInfo.username }}</span>
          <button @click="logout">注销</button>
        </div>
      </div>
      <div class="content">
        <div class="chatbox" ref="chatbox">
          <div class="message" v-for="(item, index) in messageList" :key="index">
            <div class="user">{{ item.user }}:</div>
            <div class="content">{{ item.content }}</div>
          </div>
        </div>
        <div class="inputbox">
          <form @submit.prevent="sendMessage">
            <input type="text" v-model="inputMsg" placeholder="请输入消息" required>
            <button>发送</button>
          </form>
        </div>
      </div>
    </div>
    <router-view></router-view>
  </div>
</template>

<script>
import axios from 'axios'

export default {
  name: 'App',
  data() {
    return {
      isLogin: false,
      username: '',
      password: '',
      userInfo: {},
      inputMsg: '',
      messageList: []
    }
  },
  created() {
    this.checkLogin()
  },
  methods: {
    checkLogin() {
      axios.get('/user/check_user/', {
        params: {
          username: localStorage.getItem('username')
        }
      }).then(res => {
        if (res.data.code === 200) {
          this.isLogin = true
          this.userInfo.username = localStorage.getItem('username')
          this.userInfo.avatar = localStorage.getItem('avatar')
          this.getHistory()
          this.initChat()
        }
      })
    },
    login() {
      axios.post('/user/login/', {
        username: this.username,
        password: this.password
      }).then(res => {
        if (res.data.code === 200) {
          localStorage.setItem('username', this.username)
          localStorage.setItem('avatar', 'default.jpg')
          this.isLogin = true
          this.userInfo.username = this.username
          this.userInfo.avatar = 'default.jpg'
          this.getHistory()
          this.initChat()
        } else {
          alert(res.data.msg)
        }
      })
    },
    logout() {
      axios.post('/user/logout/').then(res => {
        if (res.data.code === 200) {
          localStorage.removeItem('username')
          localStorage.removeItem('avatar')
          this.isLogin = false
          this.username = ''
          this.password = ''
                   this.userInfo = {}
          this.inputMsg = ''
          this.messageList = []
        }
      })
    },
    sendMessage() {
      if (this.inputMsg) {
        axios.post('/chatbot/send_message/', {
          content: this.inputMsg
        }).then(res => {
          if (res.data.code === 200) {
            this.messageList.push({
              user: this.userInfo.username,
              content: this.inputMsg
            })
            this.messageList.push({
              user: '聊天机器人',
              content: res.data.data.reply
            })
            this.inputMsg = ''
            this.$nextTick(() => {
              this.scrollBottom()
            })
          } else {
            alert(res.data.msg)
          }
        })
      }
    },
    getHistory() {
      axios.get('/history/get_history/').then(res => {
        if (res.data.code === 200) {
          this.messageList = res.data.data.slice(0, 50).reverse()
          this.$nextTick(() => {
            this.scrollBottom()
          })
        }
      })
    },
    initChat() {
      axios.get('/chatbot/login_itchat/').then(res => {
        if (res.data.code === 200) {
          itchat.auto_login(hotReload=True)
          itchat.run()
        }
      })
    },
    scrollBottom() {
      this.$refs.chatbox.scrollTop = this.$refs.chatbox.scrollHeight
    }
  }
}
</script>

<style>
...
</style>

FROM python:3.9

RUN apt-get update && apt-get install -y xvfb chromium chromium-driver

WORKDIR /app

COPY requirements.txt /app
RUN pip install -r requirements.txt

COPY . /app

CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]

docker build -t chatbot .
docker run -d -p 8000:8000 chatbot