lollms-webui/api/__init__.py

1355 lines
70 KiB
Python
Raw Normal View History

######
2023-06-08 06:58:02 +00:00
# Project : lollms-webui
# File : api.py
# Author : ParisNeo with the help of the community
# Supported by Nomic-AI
2023-05-21 20:46:02 +00:00
# license : Apache 2.0
# Description :
2023-06-08 06:58:02 +00:00
# A simple api to communicate with lollms-webui and its models.
######
2023-06-10 21:09:56 +00:00
from flask import request
from datetime import datetime
2023-08-02 23:07:29 +00:00
from api.db import DiscussionsDB, Discussion
2023-06-08 06:58:02 +00:00
from api.helpers import compare_lists
2023-04-23 18:28:24 +00:00
from pathlib import Path
import importlib
2023-06-21 22:43:59 +00:00
from lollms.config import InstallOption
2023-08-02 23:07:29 +00:00
from lollms.types import MSG_TYPE, SENDER_TYPES
2023-06-22 21:33:57 +00:00
from lollms.personality import AIPersonality, PersonalityBuilder
from lollms.binding import LOLLMSConfig, BindingBuilder, LLMBinding, ModelBuilder
2023-06-10 13:16:28 +00:00
from lollms.paths import LollmsPaths
2023-07-12 15:48:39 +00:00
from lollms.helpers import ASCIIColors, trace_exception
2023-07-04 00:19:20 +00:00
from lollms.app import LollmsApplication
2023-08-22 01:43:17 +00:00
from lollms.utilities import File64BitsManager, PromptReshaper
2023-05-13 22:24:26 +00:00
import multiprocessing as mp
import threading
import time
import requests
2023-05-14 11:33:45 +00:00
from tqdm import tqdm
2023-05-21 23:29:20 +00:00
import traceback
2023-05-29 20:03:12 +00:00
import sys
2023-07-16 16:57:30 +00:00
from lollms.terminal import MainMenu
2023-06-23 12:44:25 +00:00
import urllib
2023-07-04 07:24:44 +00:00
import gc
2023-07-13 14:49:54 +00:00
import ctypes
from functools import partial
2023-08-02 23:07:29 +00:00
import json
2023-07-13 14:49:54 +00:00
def terminate_thread(thread):
2023-07-15 18:02:03 +00:00
if thread:
if not thread.is_alive():
2023-07-18 14:39:05 +00:00
ASCIIColors.yellow("Thread not alive")
2023-07-15 18:02:03 +00:00
return
2023-07-13 14:49:54 +00:00
2023-07-15 18:02:03 +00:00
thread_id = thread.ident
exc = ctypes.py_object(SystemExit)
res = ctypes.pythonapi.PyThreadState_SetAsyncExc(thread_id, exc)
if res > 1:
ctypes.pythonapi.PyThreadState_SetAsyncExc(thread_id, None)
raise SystemError("Failed to terminate the thread.")
2023-07-18 14:39:05 +00:00
else:
ASCIIColors.yellow("Canceled successfully")
2023-04-23 18:28:24 +00:00
2023-04-20 17:30:03 +00:00
__author__ = "parisneo"
2023-06-08 06:58:02 +00:00
__github__ = "https://github.com/ParisNeo/lollms-webui"
2023-04-20 17:30:03 +00:00
__copyright__ = "Copyright 2023, "
__license__ = "Apache 2.0"
2023-05-13 22:24:26 +00:00
2023-05-17 15:38:40 +00:00
import subprocess
import pkg_resources
# ===========================================================
# Manage automatic install scripts
def is_package_installed(package_name):
try:
dist = pkg_resources.get_distribution(package_name)
return True
except pkg_resources.DistributionNotFound:
return False
def install_package(package_name):
try:
# Check if the package is already installed
__import__(package_name)
print(f"{package_name} is already installed.")
except ImportError:
print(f"{package_name} is not installed. Installing...")
# Install the package using pip
subprocess.check_call(["pip", "install", package_name])
print(f"{package_name} has been successfully installed.")
def parse_requirements_file(requirements_path):
with open(requirements_path, 'r') as f:
for line in f:
line = line.strip()
if not line or line.startswith('#'):
# Skip empty and commented lines
continue
package_name, _, version_specifier = line.partition('==')
package_name, _, version_specifier = line.partition('>=')
if is_package_installed(package_name):
# The package is already installed
print(f"{package_name} is already installed.")
else:
# The package is not installed, install it
if version_specifier:
install_package(f"{package_name}{version_specifier}")
else:
install_package(package_name)
# ===========================================================
2023-07-04 00:19:20 +00:00
class LoLLMsAPPI(LollmsApplication):
2023-06-10 13:16:28 +00:00
def __init__(self, config:LOLLMSConfig, socketio, config_file_path:str, lollms_paths: LollmsPaths) -> None:
2023-06-19 22:53:53 +00:00
2023-07-31 01:14:05 +00:00
super().__init__("Lollms_webui",config, lollms_paths, callback=self.process_chunk)
2023-08-19 12:06:24 +00:00
self.busy = False
2023-06-10 13:16:28 +00:00
2023-07-13 14:49:54 +00:00
2023-05-13 22:24:26 +00:00
self.socketio = socketio
self.config_file_path = config_file_path
2023-04-23 22:19:15 +00:00
self.cancel_gen = False
# Keeping track of current discussion and message
2023-05-09 05:06:01 +00:00
self._current_user_message_id = 0
self._current_ai_message_id = 0
self._message_id = 0
self.db_path = config["db_path"]
2023-06-10 13:49:41 +00:00
if Path(self.db_path).is_absolute():
# Create database object
self.db = DiscussionsDB(self.db_path)
else:
# Create database object
self.db = DiscussionsDB(self.lollms_paths.personal_path/"databases"/self.db_path)
# If the database is empty, populate it with tables
2023-06-15 16:51:04 +00:00
ASCIIColors.info("Checking discussions database... ",end="")
2023-06-15 16:49:47 +00:00
self.db.create_tables()
self.db.add_missing_columns()
2023-06-15 16:51:04 +00:00
ASCIIColors.success("ok")
# This is used to keep track of messages
2023-06-23 12:18:55 +00:00
self.download_infos={}
2023-07-13 14:49:54 +00:00
2023-07-31 01:14:05 +00:00
self.connections = {0:{
"current_discussion":None,
"generated_text":"",
"cancel_generation": False,
"generation_thread": None,
"processing":False,
"schedule_for_deletion":False
}
}
2023-07-13 14:49:54 +00:00
2023-05-13 22:24:26 +00:00
# =========================================================================================
# Socket IO stuff
# =========================================================================================
@socketio.on('connect')
def connect():
2023-07-13 14:49:54 +00:00
#Create a new connection information
self.connections[request.sid] = {
"current_discussion":None,
"generated_text":"",
"cancel_generation": False,
2023-07-15 18:02:03 +00:00
"generation_thread": None,
2023-07-26 22:03:28 +00:00
"processing":False,
"schedule_for_deletion":False
2023-08-03 09:48:13 +00:00
}
self.socketio.emit('connected', room=request.sid)
2023-06-11 19:02:06 +00:00
ASCIIColors.success(f'Client {request.sid} connected')
2023-05-13 22:24:26 +00:00
@socketio.on('disconnect')
def disconnect():
2023-07-13 14:49:54 +00:00
try:
2023-08-03 09:48:13 +00:00
self.socketio.emit('disconnected', room=request.sid)
2023-07-26 22:03:28 +00:00
if self.connections[request.sid]["processing"]:
self.connections[request.sid]["schedule_for_deletion"]=True
else:
del self.connections[request.sid]
2023-07-13 14:49:54 +00:00
except Exception as ex:
pass
2023-06-11 19:02:06 +00:00
ASCIIColors.error(f'Client {request.sid} disconnected')
2023-05-13 22:24:26 +00:00
2023-06-23 00:02:37 +00:00
2023-06-23 12:18:55 +00:00
@socketio.on('cancel_install')
def cancel_install(data):
2023-07-20 00:12:54 +00:00
try:
model_name = data["model_name"]
binding_folder = data["binding_folder"]
model_url = data["model_url"]
signature = f"{model_name}_{binding_folder}_{model_url}"
self.download_infos[signature]["cancel"]=True
self.socketio.emit('canceled', {
'status': True
},
room=request.sid
)
except Exception as ex:
trace_exception(ex)
self.socketio.emit('canceled', {
'status': False,
'error':str(ex)
},
room=request.sid
)
2023-05-13 22:24:26 +00:00
@socketio.on('install_model')
def install_model(data):
2023-07-13 14:49:54 +00:00
room_id = request.sid
2023-06-24 15:17:15 +00:00
2023-05-13 22:24:26 +00:00
def install_model_():
print("Install model triggered")
model_path = data["path"]
progress = 0
2023-06-10 21:09:56 +00:00
installation_dir = self.lollms_paths.personal_models_path/self.config["binding_name"]
2023-05-13 22:24:26 +00:00
filename = Path(model_path).name
installation_path = installation_dir / filename
print("Model install requested")
print(f"Model path : {model_path}")
2023-06-23 10:23:18 +00:00
model_name = filename
binding_folder = self.config["binding_name"]
model_url = model_path
2023-06-23 12:18:55 +00:00
signature = f"{model_name}_{binding_folder}_{model_url}"
try:
self.download_infos[signature]={
"start_time":datetime.now(),
"total_size":self.binding.get_file_size(model_path),
"downloaded_size":0,
"progress":0,
"speed":0,
"cancel":False
}
if installation_path.exists():
print("Error: Model already exists. please remove it first")
socketio.emit('install_progress',{
'status': False,
'error': f'model already exists. Please remove it first.\nThe model can be found here:{installation_path}',
'model_name' : model_name,
'binding_folder' : binding_folder,
'model_url' : model_url,
'start_time': self.download_infos[signature]['start_time'].strftime("%Y-%m-%d %H:%M:%S"),
'total_size': self.download_infos[signature]['total_size'],
'downloaded_size': self.download_infos[signature]['downloaded_size'],
'progress': self.download_infos[signature]['progress'],
'speed': self.download_infos[signature]['speed'],
}, room=room_id
)
2023-06-23 10:23:18 +00:00
socketio.emit('install_progress',{
'status': True,
'progress': progress,
'model_name' : model_name,
'binding_folder' : binding_folder,
'model_url' : model_url,
'start_time': self.download_infos[signature]['start_time'].strftime("%Y-%m-%d %H:%M:%S"),
'total_size': self.download_infos[signature]['total_size'],
'downloaded_size': self.download_infos[signature]['downloaded_size'],
'progress': self.download_infos[signature]['progress'],
'speed': self.download_infos[signature]['speed'],
2023-06-23 12:44:25 +00:00
}, room=room_id)
2023-05-13 22:24:26 +00:00
def callback(downloaded_size, total_size):
progress = (downloaded_size / total_size) * 100
now = datetime.now()
dt = (now - self.download_infos[signature]['start_time']).total_seconds()
speed = downloaded_size/dt
self.download_infos[signature]['downloaded_size'] = downloaded_size
self.download_infos[signature]['speed'] = speed
if progress - self.download_infos[signature]['progress']>2:
self.download_infos[signature]['progress'] = progress
socketio.emit('install_progress',{
'status': True,
'model_name' : model_name,
'binding_folder' : binding_folder,
'model_url' : model_url,
'start_time': self.download_infos[signature]['start_time'].strftime("%Y-%m-%d %H:%M:%S"),
'total_size': self.download_infos[signature]['total_size'],
'downloaded_size': self.download_infos[signature]['downloaded_size'],
'progress': self.download_infos[signature]['progress'],
'speed': self.download_infos[signature]['speed'],
}, room=room_id)
2023-06-28 20:08:18 +00:00
if self.download_infos[signature]["cancel"]:
raise Exception("canceled")
if hasattr(self.binding, "download_model"):
2023-07-07 16:25:18 +00:00
try:
self.binding.download_model(model_path, installation_path, callback)
2023-07-07 16:25:18 +00:00
except Exception as ex:
ASCIIColors.warning(str(ex))
trace_exception(ex)
socketio.emit('install_progress',{
'status': False,
'error': 'canceled',
'model_name' : model_name,
'binding_folder' : binding_folder,
'model_url' : model_url,
'start_time': self.download_infos[signature]['start_time'].strftime("%Y-%m-%d %H:%M:%S"),
'total_size': self.download_infos[signature]['total_size'],
'downloaded_size': self.download_infos[signature]['downloaded_size'],
'progress': self.download_infos[signature]['progress'],
'speed': self.download_infos[signature]['speed'],
}, room=room_id
)
del self.download_infos[signature]
try:
installation_path.unlink()
except Exception as ex:
ASCIIColors.error(f"Couldn't delete file. Please try to remove it manually.\n{installation_path}")
return
2023-06-23 12:18:55 +00:00
else:
try:
self.download_file(model_path, installation_path, callback)
except Exception as ex:
ASCIIColors.warning(str(ex))
trace_exception(ex)
socketio.emit('install_progress',{
'status': False,
'error': 'canceled',
'model_name' : model_name,
'binding_folder' : binding_folder,
'model_url' : model_url,
'start_time': self.download_infos[signature]['start_time'].strftime("%Y-%m-%d %H:%M:%S"),
'total_size': self.download_infos[signature]['total_size'],
'downloaded_size': self.download_infos[signature]['downloaded_size'],
'progress': self.download_infos[signature]['progress'],
'speed': self.download_infos[signature]['speed'],
}, room=room_id
)
del self.download_infos[signature]
installation_path.unlink()
return
socketio.emit('install_progress',{
'status': True,
'error': '',
'model_name' : model_name,
'binding_folder' : binding_folder,
'model_url' : model_url,
'start_time': self.download_infos[signature]['start_time'].strftime("%Y-%m-%d %H:%M:%S"),
'total_size': self.download_infos[signature]['total_size'],
'downloaded_size': self.download_infos[signature]['downloaded_size'],
'progress': 100,
'speed': self.download_infos[signature]['speed'],
}, room=room_id)
del self.download_infos[signature]
except Exception as ex:
trace_exception(ex)
socketio.emit('install_progress',{
'status': False,
'error': str(ex),
'model_name' : model_name,
'binding_folder' : binding_folder,
'model_url' : model_url,
'start_time': '',
'total_size': 0,
'downloaded_size': 0,
'progress': 0,
'speed': 0,
}, room=room_id
)
2023-05-13 22:24:26 +00:00
tpe = threading.Thread(target=install_model_, args=())
tpe.start()
2023-06-22 21:23:56 +00:00
2023-05-13 22:24:26 +00:00
@socketio.on('uninstall_model')
def uninstall_model(data):
model_path = data['path']
2023-06-10 21:09:56 +00:00
installation_dir = self.lollms_paths.personal_models_path/self.config["binding_name"]
2023-05-13 22:24:26 +00:00
filename = Path(model_path).name
installation_path = installation_dir / filename
2023-06-23 10:30:05 +00:00
model_name = filename
binding_folder = self.config["binding_name"]
2023-05-13 22:24:26 +00:00
if not installation_path.exists():
2023-06-23 10:30:05 +00:00
socketio.emit('install_progress',{
'status': False,
'error': 'The model does not exist',
'model_name' : model_name,
'binding_folder' : binding_folder
}, room=request.sid)
2023-07-07 17:34:30 +00:00
try:
installation_path.unlink()
2023-07-26 16:12:24 +00:00
socketio.emit('install_progress',{
'status': True,
'error': '',
'model_name' : model_name,
'binding_folder' : binding_folder
}, room=request.sid)
2023-07-07 17:34:30 +00:00
except Exception as ex:
ASCIIColors.error(f"Couldn't delete {installation_path}, please delete it manually and restart the app")
2023-07-26 16:12:24 +00:00
socketio.emit('install_progress',{
'status': False,
'error': f"Couldn't delete {installation_path}, please delete it manually and restart the app",
'model_name' : model_name,
'binding_folder' : binding_folder
}, room=request.sid)
2023-06-22 21:33:57 +00:00
2023-08-02 23:07:29 +00:00
@socketio.on('new_discussion')
def new_discussion(data):
client_id = request.sid
title = data["title"]
self.connections[client_id]["current_discussion"] = self.db.create_discussion(title)
# Get the current timestamp
timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
# Return a success response
if self.connections[client_id]["current_discussion"] is None:
self.connections[client_id]["current_discussion"] = self.db.load_last_discussion()
if self.personality.welcome_message!="":
message = self.connections[client_id]["current_discussion"].add_message(
message_type = MSG_TYPE.MSG_TYPE_FULL.value if self.personality.include_welcome_message_in_disucssion else MSG_TYPE.MSG_TYPE_FULL_INVISIBLE_TO_AI.value,
sender_type = SENDER_TYPES.SENDER_TYPES_AI.value,
sender = self.personality.name,
content = self.personality.welcome_message,
metadata = None,
rank = 0,
parent_message_id = -1,
binding = self.config.binding_name,
model = self.config.model_name,
personality = self.config.personalities[self.config.active_personality_id],
created_at=None,
finished_generating_at=None
)
self.socketio.emit('discussion_created',
{'id':self.connections[client_id]["current_discussion"].discussion_id},
room=client_id
)
else:
self.socketio.emit('discussion_created',
{'id':0},
room=client_id
)
@socketio.on('load_discussion')
def load_discussion(data):
client_id = request.sid
2023-08-04 22:28:36 +00:00
ASCIIColors.yellow(f"Loading discussion for client {client_id}")
2023-08-02 23:07:29 +00:00
if "id" in data:
discussion_id = data["id"]
self.connections[client_id]["current_discussion"] = Discussion(discussion_id, self.db)
else:
if self.connections[client_id]["current_discussion"] is not None:
discussion_id = self.connections[client_id]["current_discussion"].discussion_id
self.connections[client_id]["current_discussion"] = Discussion(discussion_id, self.db)
else:
self.connections[client_id]["current_discussion"] = self.db.create_discussion()
messages = self.connections[client_id]["current_discussion"].get_messages()
2023-08-17 23:29:53 +00:00
jsons = [m.to_json() for m in messages]
2023-08-02 23:07:29 +00:00
self.socketio.emit('discussion',
2023-08-17 23:29:53 +00:00
jsons,
2023-08-02 23:07:29 +00:00
room=client_id
)
2023-08-25 00:12:33 +00:00
2023-06-22 21:33:57 +00:00
@socketio.on('upload_file')
def upload_file(data):
file = data['file']
filename = file.filename
save_path = self.lollms_paths.personal_uploads_path/filename # Specify the desired folder path
try:
2023-06-22 21:39:05 +00:00
if not self.personality.processor is None:
file.save(save_path)
2023-08-22 01:43:17 +00:00
self.personality.processor.add_file(save_path, partial(self.process_chunk, client_id = request.sid))
2023-06-22 21:39:05 +00:00
# File saved successfully
socketio.emit('progress', {'status':True, 'progress': 100})
2023-06-23 00:02:37 +00:00
2023-06-22 21:39:05 +00:00
else:
2023-08-22 01:43:17 +00:00
file.save(save_path)
self.personality.add_file(save_path, partial(self.process_chunk, client_id = request.sid))
# File saved successfully
socketio.emit('progress', {'status':True, 'progress': 100})
2023-06-22 21:33:57 +00:00
except Exception as e:
# Error occurred while saving the file
2023-06-22 21:39:05 +00:00
socketio.emit('progress', {'status':False, 'error': str(e)})
2023-05-13 22:24:26 +00:00
2023-06-25 20:56:06 +00:00
@socketio.on('cancel_generation')
def cancel_generation():
2023-07-13 14:49:54 +00:00
client_id = request.sid
2023-06-25 20:56:06 +00:00
self.cancel_gen = True
2023-07-13 14:49:54 +00:00
#kill thread
ASCIIColors.error(f'Client {request.sid} requested cancelling generation')
terminate_thread(self.connections[client_id]['generation_thread'])
2023-06-25 20:56:06 +00:00
ASCIIColors.error(f'Client {request.sid} canceled generation')
2023-07-13 14:49:54 +00:00
self.cancel_gen = False
2023-08-19 12:06:24 +00:00
self.busy=False
2023-08-25 00:12:33 +00:00
@socketio.on('get_personality_files')
def get_personality_files(data):
client_id = request.sid
self.connections[client_id]["generated_text"] = ""
self.connections[client_id]["cancel_generation"] = False
try:
self.personality.setCallback(partial(self.process_chunk,client_id = client_id))
except Exception as ex:
trace_exception(ex)
2023-07-31 22:51:06 +00:00
@socketio.on('send_file')
def send_file(data):
client_id = request.sid
self.connections[client_id]["generated_text"] = ""
self.connections[client_id]["cancel_generation"] = False
try:
self.personality.setCallback(partial(self.process_chunk,client_id = client_id))
ASCIIColors.info("Recovering file from front end")
path:Path = self.lollms_paths.personal_uploads_path / self.personality.personality_folder_name
path.mkdir(parents=True, exist_ok=True)
file_path = path / data["filename"]
2023-08-23 23:34:18 +00:00
File64BitsManager.b642file(data["fileData"],file_path)
2023-07-31 22:51:06 +00:00
if self.personality.processor:
2023-08-25 00:12:33 +00:00
result = self.personality.processor.add_file(file_path, partial(self.process_chunk, client_id=client_id))
2023-08-23 02:21:58 +00:00
else:
2023-08-25 00:12:33 +00:00
result = self.personality.add_file(file_path, partial(self.process_chunk, client_id=client_id))
if result:
self.socketio.emit('file_received',
{
"status":True,
"filename":data["filename"],
}, room=client_id
)
else:
self.socketio.emit('file_received',
{
"status":False,
"filename":data["filename"],
"error":"Couldn't receive file: Verify that file type is compatible with the personality"
}, room=client_id
)
2023-07-31 22:51:06 +00:00
except Exception as ex:
ASCIIColors.error(ex)
trace_exception(ex)
self.socketio.emit('file_received',
{
"status":False,
2023-08-25 00:12:33 +00:00
"filename":data["filename"],
2023-07-31 22:51:06 +00:00
"error":"Couldn't receive file: "+str(ex)
}, room=client_id
2023-08-25 00:12:33 +00:00
)
self.close_message(client_id)
2023-05-13 22:24:26 +00:00
2023-08-19 01:25:36 +00:00
2023-08-19 12:06:24 +00:00
@self.socketio.on('cancel_text_generation')
def cancel_text_generation(data):
client_id = request.sid
2023-08-19 16:48:08 +00:00
self.connections[client_id]["requested_stop"]=True
2023-08-19 12:06:24 +00:00
print(f"Client {client_id} requested canceling generation")
self.socketio.emit("generation_canceled", {"message":"Generation is canceled."}, room=client_id)
self.socketio.sleep(0)
self.busy = False
2023-08-19 01:25:36 +00:00
2023-08-19 22:12:08 +00:00
@self.socketio.on('execute_python_code')
def execute_python_code(data):
"""Executes Python code and returns the output."""
client_id = request.sid
code = data["code"]
# Import the necessary modules.
import io
import sys
import time
# Create a Python interpreter.
interpreter = io.StringIO()
sys.stdout = interpreter
# Execute the code.
start_time = time.time()
exec(code)
end_time = time.time()
# Get the output.
output = interpreter.getvalue()
self.socketio.emit("execution_output", {"output":output,"execution_time":end_time - start_time}, room=client_id)
2023-08-19 01:25:36 +00:00
# A copy of the original lollms-server generation code needed for playground
@self.socketio.on('generate_text')
def handle_generate_text(data):
client_id = request.sid
ASCIIColors.info(f"Text generation requested by client: {client_id}")
2023-08-19 12:06:24 +00:00
if self.busy:
self.socketio.emit("busy", {"message":"I am busy. Come back later."}, room=client_id)
2023-08-19 01:25:36 +00:00
self.socketio.sleep(0)
2023-08-19 12:06:24 +00:00
ASCIIColors.warning(f"OOps request {client_id} refused!! Server busy")
2023-08-19 01:25:36 +00:00
return
def generate_text():
2023-08-19 12:06:24 +00:00
self.busy = True
2023-08-19 01:25:36 +00:00
try:
model = self.model
self.connections[client_id]["is_generating"]=True
self.connections[client_id]["requested_stop"]=False
prompt = data['prompt']
2023-08-19 12:06:24 +00:00
tokenized = model.tokenize(prompt)
personality_id = data.get('personality', -1)
n_crop = data.get('n_crop', len(tokenized))
if n_crop!=-1:
prompt = model.detokenize(tokenized[-n_crop:])
2023-08-19 01:25:36 +00:00
n_predicts = data["n_predicts"]
parameters = data.get("parameters",{
"temperature":self.config["temperature"],
"top_k":self.config["top_k"],
"top_p":self.config["top_p"],
"repeat_penalty":self.config["repeat_penalty"],
"repeat_last_n":self.config["repeat_last_n"],
"seed":self.config["seed"]
})
if personality_id==-1:
# Raw text generation
self.answer = {"full_text":""}
def callback(text, message_type: MSG_TYPE, metadata:dict={}):
if message_type == MSG_TYPE.MSG_TYPE_CHUNK:
ASCIIColors.success(f"generated:{len(self.answer['full_text'].split())} words", end='\r')
self.answer["full_text"] = self.answer["full_text"] + text
self.socketio.emit('text_chunk', {'chunk': text, 'type':MSG_TYPE.MSG_TYPE_CHUNK.value}, room=client_id)
self.socketio.sleep(0)
if client_id in self.connections:# Client disconnected
if self.connections[client_id]["requested_stop"]:
return False
else:
return True
else:
return False
tk = model.tokenize(prompt)
n_tokens = len(tk)
fd = model.detokenize(tk[-min(self.config.ctx_size-n_predicts,n_tokens):])
try:
ASCIIColors.print("warming up", ASCIIColors.color_bright_cyan)
generated_text = model.generate(fd,
n_predict=n_predicts,
callback=callback,
temperature = parameters["temperature"],
top_k = parameters["top_k"],
top_p = parameters["top_p"],
repeat_penalty = parameters["repeat_penalty"],
repeat_last_n = parameters["repeat_last_n"],
seed = parameters["seed"]
)
ASCIIColors.success(f"\ndone")
if client_id in self.connections:
if not self.connections[client_id]["requested_stop"]:
# Emit the generated text to the client
self.socketio.emit('text_generated', {'text': generated_text}, room=client_id)
self.socketio.sleep(0)
except Exception as ex:
self.socketio.emit('generation_error', {'error': str(ex)}, room=client_id)
ASCIIColors.error(f"\ndone")
2023-08-19 12:06:24 +00:00
self.busy = False
2023-08-19 01:25:36 +00:00
else:
try:
personality: AIPersonality = self.personalities[personality_id]
ump = self.config.discussion_prompt_separator +self.config.user_name+": " if self.config.use_user_name_in_discussions else self.personality.user_message_prefix
personality.model = model
cond_tk = personality.model.tokenize(personality.personality_conditioning)
n_cond_tk = len(cond_tk)
# Placeholder code for text generation
# Replace this with your actual text generation logic
print(f"Text generation requested by client: {client_id}")
self.answer["full_text"] = ''
full_discussion_blocks = self.connections[client_id]["full_discussion_blocks"]
if prompt != '':
if personality.processor is not None and personality.processor_cfg["process_model_input"]:
preprocessed_prompt = personality.processor.process_model_input(prompt)
else:
preprocessed_prompt = prompt
if personality.processor is not None and personality.processor_cfg["custom_workflow"]:
full_discussion_blocks.append(ump)
full_discussion_blocks.append(preprocessed_prompt)
else:
full_discussion_blocks.append(ump)
full_discussion_blocks.append(preprocessed_prompt)
full_discussion_blocks.append(personality.link_text)
full_discussion_blocks.append(personality.ai_message_prefix)
full_discussion = personality.personality_conditioning + ''.join(full_discussion_blocks)
def callback(text, message_type: MSG_TYPE, metadata:dict={}):
if message_type == MSG_TYPE.MSG_TYPE_CHUNK:
self.answer["full_text"] = self.answer["full_text"] + text
self.socketio.emit('text_chunk', {'chunk': text}, room=client_id)
self.socketio.sleep(0)
try:
if self.connections[client_id]["requested_stop"]:
return False
else:
return True
except: # If the client is disconnected then we stop talking to it
return False
tk = personality.model.tokenize(full_discussion)
n_tokens = len(tk)
fd = personality.model.detokenize(tk[-min(self.config.ctx_size-n_cond_tk-personality.model_n_predicts,n_tokens):])
if personality.processor is not None and personality.processor_cfg["custom_workflow"]:
ASCIIColors.info("processing...")
generated_text = personality.processor.run_workflow(prompt, previous_discussion_text=personality.personality_conditioning+fd, callback=callback)
else:
ASCIIColors.info("generating...")
generated_text = personality.model.generate(
personality.personality_conditioning+fd,
n_predict=personality.model_n_predicts,
callback=callback)
if personality.processor is not None and personality.processor_cfg["process_model_output"]:
generated_text = personality.processor.process_model_output(generated_text)
full_discussion_blocks.append(generated_text.strip())
ASCIIColors.success("\ndone")
# Emit the generated text to the client
self.socketio.emit('text_generated', {'text': generated_text}, room=client_id)
self.socketio.sleep(0)
except Exception as ex:
self.socketio.emit('generation_error', {'error': str(ex)}, room=client_id)
ASCIIColors.error(f"\ndone")
2023-08-19 12:06:24 +00:00
self.busy = False
2023-08-19 01:25:36 +00:00
except Exception as ex:
trace_exception(ex)
self.socketio.emit('generation_error', {'error': str(ex)}, room=client_id)
2023-08-19 12:06:24 +00:00
self.busy = False
2023-08-19 01:25:36 +00:00
# Start the text generation task in a separate thread
task = self.socketio.start_background_task(target=generate_text)
2023-05-13 22:24:26 +00:00
@socketio.on('generate_msg')
def generate_msg(data):
2023-07-13 14:49:54 +00:00
client_id = request.sid
self.connections[client_id]["generated_text"]=""
self.connections[client_id]["cancel_generation"]=False
2023-07-15 18:02:03 +00:00
2023-07-20 00:12:54 +00:00
if not self.model:
2023-08-02 23:07:29 +00:00
self.notify("Model not selected. Please select a model", False, client_id)
2023-07-20 00:12:54 +00:00
return
2023-07-16 18:22:25 +00:00
2023-08-19 12:06:24 +00:00
if not self.busy:
2023-08-02 23:07:29 +00:00
if self.connections[client_id]["current_discussion"] is None:
2023-05-14 09:10:49 +00:00
if self.db.does_last_discussion_have_messages():
2023-08-02 23:07:29 +00:00
self.connections[client_id]["current_discussion"] = self.db.create_discussion()
2023-05-14 09:10:49 +00:00
else:
2023-08-02 23:07:29 +00:00
self.connections[client_id]["current_discussion"] = self.db.load_last_discussion()
2023-05-13 22:24:26 +00:00
2023-08-02 23:07:29 +00:00
prompt = data["prompt"]
2023-07-19 15:41:23 +00:00
ump = self.config.discussion_prompt_separator +self.config.user_name+": " if self.config.use_user_name_in_discussions else self.personality.user_message_prefix
2023-08-02 23:07:29 +00:00
message = self.connections[client_id]["current_discussion"].add_message(
message_type = MSG_TYPE.MSG_TYPE_FULL.value,
sender_type = SENDER_TYPES.SENDER_TYPES_USER.value,
sender = ump.replace(self.config.discussion_prompt_separator,"").replace(":",""),
content=prompt,
metadata=None,
parent_message_id=self.message_id
2023-05-14 09:10:49 +00:00
)
2023-04-20 17:30:03 +00:00
2023-08-04 22:28:36 +00:00
ASCIIColors.green("Starting message generation by "+self.personality.name)
2023-08-02 23:07:29 +00:00
self.connections[client_id]['generation_thread'] = threading.Thread(target=self.start_message_generation, args=(message, message.id, client_id))
2023-07-13 14:49:54 +00:00
self.connections[client_id]['generation_thread'].start()
2023-07-06 09:37:12 +00:00
self.socketio.sleep(0.01)
2023-06-23 00:02:37 +00:00
ASCIIColors.info("Started generation task")
2023-08-19 12:06:24 +00:00
self.busy=True
2023-07-13 14:49:54 +00:00
#tpe = threading.Thread(target=self.start_message_generation, args=(message, message_id, client_id))
2023-06-21 22:43:59 +00:00
#tpe.start()
2023-05-14 09:10:49 +00:00
else:
2023-08-19 12:06:24 +00:00
self.notify("I am busy. Come back later.", False, client_id)
2023-05-13 22:24:26 +00:00
@socketio.on('generate_msg_from')
2023-08-02 23:07:29 +00:00
def generate_msg_from(data):
2023-07-13 14:49:54 +00:00
client_id = request.sid
2023-08-02 23:07:29 +00:00
if self.connections[client_id]["current_discussion"] is None:
2023-08-04 22:28:36 +00:00
ASCIIColors.warning("Please select a discussion")
self.notify("Please select a discussion first", False, client_id)
2023-08-02 23:07:29 +00:00
return
2023-07-15 21:06:28 +00:00
id_ = data['id']
2023-08-04 22:28:36 +00:00
if id_==-1:
message = self.connections[client_id]["current_discussion"].current_message
else:
2023-08-23 02:21:58 +00:00
message = self.connections[client_id]["current_discussion"].get_message(id_)
2023-08-02 23:07:29 +00:00
if message is None:
return
self.connections[client_id]['generation_thread'] = threading.Thread(target=self.start_message_generation, args=(message, message.id, client_id))
2023-07-13 14:49:54 +00:00
self.connections[client_id]['generation_thread'].start()
# generation status
self.generating=False
2023-06-25 17:26:22 +00:00
ASCIIColors.blue(f"Your personal data is stored here :",end="")
ASCIIColors.green(f"{self.lollms_paths.personal_path}")
2023-05-22 06:52:48 +00:00
2023-06-30 22:14:51 +00:00
@socketio.on('continue_generate_msg_from')
def handle_connection(data):
2023-07-13 14:49:54 +00:00
client_id = request.sid
2023-08-02 23:07:29 +00:00
if self.connections[client_id]["current_discussion"] is None:
2023-08-04 22:28:36 +00:00
ASCIIColors.yellow("Please select a discussion")
2023-08-02 23:07:29 +00:00
self.notify("Please select a discussion", False, client_id)
return
id_ = data['id']
2023-08-04 22:28:36 +00:00
if id_==-1:
message = self.connections[client_id]["current_discussion"].current_message
else:
2023-08-23 02:21:58 +00:00
message = self.connections[client_id]["current_discussion"].get_message(id_)
2023-08-02 23:07:29 +00:00
self.connections[client_id]['generation_thread'] = threading.Thread(target=self.start_message_generation, args=(message, message.id, client_id, True))
2023-07-13 14:49:54 +00:00
self.connections[client_id]['generation_thread'].start()
2023-06-30 22:14:51 +00:00
# generation status
self.generating=False
ASCIIColors.blue(f"Your personal data is stored here :",end="")
ASCIIColors.green(f"{self.lollms_paths.personal_path}")
2023-07-17 23:04:48 +00:00
def rebuild_personalities(self, reload_all=False):
2023-07-29 00:41:09 +00:00
if reload_all:
self.mounted_personalities=[]
2023-06-21 22:43:59 +00:00
loaded = self.mounted_personalities
loaded_names = [f"{p.category}/{p.personality_folder_name}:{p.selected_language}" if p.selected_language else f"{p.category}/{p.personality_folder_name}" for p in loaded]
2023-06-21 22:43:59 +00:00
mounted_personalities=[]
ASCIIColors.success(f" ╔══════════════════════════════════════════════════╗ ")
ASCIIColors.success(f" ║ Building mounted Personalities ║ ")
ASCIIColors.success(f" ╚══════════════════════════════════════════════════╝ ")
2023-06-23 07:36:52 +00:00
to_remove=[]
2023-06-21 22:43:59 +00:00
for i,personality in enumerate(self.config['personalities']):
2023-07-04 09:26:57 +00:00
if i==self.config["active_personality_id"]:
ASCIIColors.red("*", end="")
ASCIIColors.green(f" {personality}")
else:
ASCIIColors.yellow(f" {personality}")
2023-07-29 00:41:09 +00:00
if personality in loaded_names:
2023-06-21 22:43:59 +00:00
mounted_personalities.append(loaded[loaded_names.index(personality)])
else:
personality_path = self.lollms_paths.personalities_zoo_path/f"{personality}" if not ":" in personality else self.lollms_paths.personalities_zoo_path/f"{personality.split(':')[0]}"
2023-06-21 22:43:59 +00:00
try:
personality = AIPersonality(personality_path,
self.lollms_paths,
self.config,
2023-06-21 23:40:15 +00:00
model=self.model,
selected_language=personality.split(":")[1] if ":" in personality else None,
2023-06-21 23:23:34 +00:00
run_scripts=True)
2023-06-21 22:43:59 +00:00
mounted_personalities.append(personality)
except Exception as ex:
2023-06-21 23:23:34 +00:00
ASCIIColors.error(f"Personality file not found or is corrupted ({personality_path}).\nReturned the following exception:{ex}\nPlease verify that the personality you have selected exists or select another personality. Some updates may lead to change in personality name or category, so check the personality selection in settings to be sure.")
2023-06-23 07:36:52 +00:00
ASCIIColors.info("Trying to force reinstall")
2023-06-21 22:43:59 +00:00
if self.config["debug"]:
print(ex)
2023-06-23 06:49:05 +00:00
try:
personality = AIPersonality(
personality_path,
self.lollms_paths,
self.config,
self.model,
run_scripts=True,
selected_language=personality.split(":")[1] if ":" in personality else None,
2023-06-23 06:49:05 +00:00
installation_option=InstallOption.FORCE_INSTALL)
2023-06-23 07:36:52 +00:00
mounted_personalities.append(personality)
2023-07-12 15:48:39 +00:00
except Exception as ex:
2023-06-23 06:49:05 +00:00
ASCIIColors.error(f"Couldn't load personality at {personality_path}")
2023-07-12 15:48:39 +00:00
trace_exception(ex)
2023-06-23 07:36:52 +00:00
ASCIIColors.info(f"Unmounting personality")
to_remove.append(i)
personality = AIPersonality(None,
self.lollms_paths,
2023-06-23 06:49:05 +00:00
self.config,
self.model,
run_scripts=True,
installation_option=InstallOption.FORCE_INSTALL)
2023-06-23 07:36:52 +00:00
mounted_personalities.append(personality)
2023-06-23 06:49:05 +00:00
ASCIIColors.info("Reverted to default personality")
2023-06-21 22:43:59 +00:00
print(f'selected : {self.config["active_personality_id"]}')
ASCIIColors.success(f" ╔══════════════════════════════════════════════════╗ ")
ASCIIColors.success(f" ║ Done ║ ")
ASCIIColors.success(f" ╚══════════════════════════════════════════════════╝ ")
2023-06-23 07:36:52 +00:00
# Sort the indices in descending order to ensure correct removal
to_remove.sort(reverse=True)
# Remove elements from the list based on the indices
for index in to_remove:
if 0 <= index < len(mounted_personalities):
mounted_personalities.pop(index)
self.config["personalities"].pop(index)
ASCIIColors.info(f"removed personality {personality_path}")
if self.config["active_personality_id"]>=len(self.config["personalities"]):
self.config["active_personality_id"]=0
2023-06-21 22:43:59 +00:00
return mounted_personalities
2023-06-22 21:33:57 +00:00
# ================================== LOLLMSApp
2023-05-09 05:06:01 +00:00
#properties
@property
def message_id(self):
return self._message_id
2023-07-15 21:06:28 +00:00
@message_id.setter
def message_id(self, id):
self._message_id=id
2023-05-09 05:06:01 +00:00
@property
def current_user_message_id(self):
return self._current_user_message_id
@current_user_message_id.setter
def current_user_message_id(self, id):
self._current_user_message_id=id
self._message_id = id
@property
def current_ai_message_id(self):
return self._current_ai_message_id
@current_ai_message_id.setter
def current_ai_message_id(self, id):
self._current_ai_message_id=id
self._message_id = id
2023-05-13 22:24:26 +00:00
def download_file(self, url, installation_path, callback=None):
"""
2023-05-14 11:33:45 +00:00
Downloads a file from a URL, reports the download progress using a callback function, and displays a progress bar.
2023-05-13 22:24:26 +00:00
Args:
url (str): The URL of the file to download.
2023-05-14 11:33:45 +00:00
installation_path (str): The path where the file should be saved.
2023-05-13 22:24:26 +00:00
callback (function, optional): A callback function to be called during the download
with the progress percentage as an argument. Defaults to None.
"""
2023-05-14 09:10:49 +00:00
try:
2023-05-14 11:33:45 +00:00
response = requests.get(url, stream=True)
# Get the file size from the response headers
total_size = int(response.headers.get('content-length', 0))
with open(installation_path, 'wb') as file:
downloaded_size = 0
with tqdm(total=total_size, unit='B', unit_scale=True, ncols=80) as progress_bar:
for chunk in response.iter_content(chunk_size=8192):
if chunk:
file.write(chunk)
downloaded_size += len(chunk)
if callback is not None:
2023-06-23 12:44:25 +00:00
callback(downloaded_size, total_size)
2023-05-14 11:33:45 +00:00
progress_bar.update(len(chunk))
2023-05-09 05:06:01 +00:00
2023-05-14 09:10:49 +00:00
if callback is not None:
callback(total_size, total_size)
2023-05-14 11:33:45 +00:00
print("File downloaded successfully")
except Exception as e:
print("Couldn't download file:", str(e))
2023-07-13 23:42:29 +00:00
def prepare_reception(self, client_id):
self.connections[client_id]["generated_text"] = ""
2023-07-05 00:19:11 +00:00
self.nb_received_tokens = 0
2023-08-02 23:07:29 +00:00
def prepare_query(self, client_id, message_id=-1, is_continue=False):
messages = self.connections[client_id]["current_discussion"].get_messages()
full_message_list = []
2023-07-15 21:06:28 +00:00
for i, message in enumerate(messages):
2023-08-02 23:07:29 +00:00
if message.id< message_id or (message_id==-1 and i<len(messages)-1):
if message.message_type<=MSG_TYPE.MSG_TYPE_FULL_INVISIBLE_TO_USER.value and message.message_type!=MSG_TYPE.MSG_TYPE_FULL_INVISIBLE_TO_AI.value:
full_message_list.append("\n"+self.config.discussion_prompt_separator+message.sender+": "+message.content.strip())
2023-05-16 23:48:35 +00:00
else:
break
2023-07-27 23:16:26 +00:00
link_text = "\n" #self.personality.link_text
2023-06-30 22:14:51 +00:00
if not is_continue:
2023-08-23 21:29:42 +00:00
full_message_list.append(self.config.discussion_prompt_separator +message.sender.replace(":","")+": "+message.content.strip()+link_text+self.personality.ai_message_prefix)
2023-06-30 22:14:51 +00:00
else:
2023-08-23 21:29:42 +00:00
full_message_list.append(self.config.discussion_prompt_separator +message.sender.replace(":","")+": "+message.content.strip())
2023-04-16 11:47:39 +00:00
2023-08-02 23:07:29 +00:00
composed_messages = link_text.join(full_message_list)
2023-07-15 21:06:28 +00:00
t = self.model.tokenize(composed_messages)
2023-07-17 23:04:48 +00:00
cond_tk = self.model.tokenize(self.personality.personality_conditioning)
2023-07-13 17:26:15 +00:00
n_t = len(t)
2023-07-17 23:04:48 +00:00
n_cond_tk = len(cond_tk)
2023-07-13 17:26:15 +00:00
max_prompt_stx_size = 3*int(self.config.ctx_size/4)
2023-07-17 23:04:48 +00:00
if n_cond_tk+n_t>max_prompt_stx_size:
nb_tk = max_prompt_stx_size-n_cond_tk
2023-07-15 21:06:28 +00:00
composed_messages = self.model.detokenize(t[-nb_tk:])
2023-07-13 17:26:15 +00:00
ASCIIColors.warning(f"Cropping discussion to fit context [using {nb_tk} tokens/{self.config.ctx_size}]")
2023-08-23 02:21:58 +00:00
discussion_messages = composed_messages
2023-04-16 11:47:39 +00:00
2023-08-23 23:34:18 +00:00
2023-07-15 21:06:28 +00:00
2023-08-23 02:21:58 +00:00
if len(self.personality.files)>0 and self.personality.vectorizer:
2023-08-25 00:12:33 +00:00
pr = PromptReshaper("!@>document chunks:\n{{doc}}\n{{conditionning}}\n{{content}}")
2023-08-23 02:21:58 +00:00
emb = self.personality.vectorizer.embed_query(message.content)
2023-08-23 23:34:18 +00:00
docs, sorted_similarities = self.personality.vectorizer.recover_text(emb, top_k=self.config.data_vectorization_nb_chunks)
2023-08-25 00:12:33 +00:00
str_docs = ""
for doc, infos in zip(docs, sorted_similarities):
str_docs+=f"document chunk:\nchunk path: {infos[0]}\nchunk content:{doc}"
2023-08-23 02:21:58 +00:00
discussion_messages = pr.build({
2023-08-25 00:12:33 +00:00
"doc":str_docs,
2023-08-23 02:21:58 +00:00
"conditionning":self.personality.personality_conditioning,
"content":discussion_messages
}, self.model.tokenize, self.model.detokenize, self.config.ctx_size, place_holders_to_sacrifice=["content"])
else:
pr = PromptReshaper("{{conditionning}}\n{{content}}")
discussion_messages = pr.build({
"conditionning":self.personality.personality_conditioning,
"content":discussion_messages
}, self.model.tokenize, self.model.detokenize, self.config.ctx_size, place_holders_to_sacrifice=["content"])
2023-08-23 23:34:18 +00:00
if self.config["debug"]:
tokens = self.model.tokenize(discussion_messages)
ASCIIColors.yellow(discussion_messages)
ASCIIColors.info(f"prompt size:{len(tokens)} tokens")
2023-08-23 02:21:58 +00:00
2023-08-02 23:07:29 +00:00
return discussion_messages, message.content, tokens
2023-04-17 22:23:31 +00:00
2023-08-02 23:07:29 +00:00
def get_discussion_to(self, client_id, message_id=-1):
messages = self.connections[client_id]["current_discussion"].get_messages()
full_message_list = []
2023-07-19 15:41:23 +00:00
ump = self.config.discussion_prompt_separator +self.config.user_name+": " if self.config.use_user_name_in_discussions else self.personality.user_message_prefix
2023-07-16 16:57:30 +00:00
2023-04-17 22:23:31 +00:00
for message in messages:
if message["id"]<= message_id or message_id==-1:
2023-07-06 18:56:21 +00:00
if message["type"]!=MSG_TYPE.MSG_TYPE_FULL_INVISIBLE_TO_USER:
2023-04-30 20:40:19 +00:00
if message["sender"]==self.personality.name:
2023-08-02 23:07:29 +00:00
full_message_list.append(self.personality.ai_message_prefix+message["content"])
2023-04-17 22:23:31 +00:00
else:
2023-08-02 23:07:29 +00:00
full_message_list.append(ump + message["content"])
2023-04-17 22:23:31 +00:00
2023-07-27 23:16:26 +00:00
link_text = "\n"# self.personality.link_text
2023-04-17 22:23:31 +00:00
2023-08-02 23:07:29 +00:00
if len(full_message_list) > self.config["nb_messages_to_remember"]:
discussion_messages = self.personality.personality_conditioning+ link_text.join(full_message_list[-self.config["nb_messages_to_remember"]:])
2023-04-17 22:23:31 +00:00
else:
2023-08-02 23:07:29 +00:00
discussion_messages = self.personality.personality_conditioning+ link_text.join(full_message_list)
2023-04-17 22:23:31 +00:00
return discussion_messages # Removes the last return
2023-06-21 22:43:59 +00:00
def remove_text_from_string(self, string, text_to_find):
"""
Removes everything from the first occurrence of the specified text in the string (case-insensitive).
Parameters:
string (str): The original string.
text_to_find (str): The text to find in the string.
Returns:
str: The updated string.
"""
index = string.lower().find(text_to_find.lower())
2023-04-23 22:19:15 +00:00
2023-06-21 22:43:59 +00:00
if index != -1:
string = string[:index]
return string
2023-08-02 23:07:29 +00:00
def notify(self, content, status, client_id):
self.socketio.emit('notification', {
'content': content,# self.connections[client_id]["generated_text"],
'status': status
}, room=client_id
)
def new_message(self,
client_id,
sender,
2023-08-17 23:29:53 +00:00
content,
parameters=None,
metadata=[],
2023-08-02 23:07:29 +00:00
message_type:MSG_TYPE=MSG_TYPE.MSG_TYPE_FULL,
sender_type:SENDER_TYPES=SENDER_TYPES.SENDER_TYPES_AI
):
msg = self.connections[client_id]["current_discussion"].add_message(
message_type = message_type.value,
sender_type = sender_type.value,
sender = sender,
content = content,
2023-08-17 23:29:53 +00:00
metadata = json.dumps(metadata, indent=4) if metadata is not None and type(metadata) == list else metadata,
2023-08-02 23:07:29 +00:00
rank = 0,
parent_message_id = self.connections[client_id]["current_discussion"].current_message.id,
binding = self.config["binding_name"],
model = self.config["model_name"],
personality = self.config["personalities"][self.config["active_personality_id"]],
) # first the content is empty, but we'll fill it at the end
self.socketio.emit('new_message',
{
"sender": self.personality.name,
"message_type": message_type.value,
"sender_type": SENDER_TYPES.SENDER_TYPES_AI.value,
"content": content,
2023-08-17 23:29:53 +00:00
"parameters": parameters,
"metadata": json.dumps(metadata, indent=4) if metadata is not None and type(metadata)== list else metadata,
2023-08-02 23:07:29 +00:00
"id": msg.id,
"parent_message_id": msg.parent_message_id,
'binding': self.config["binding_name"],
'model' : self.config["model_name"],
'personality': self.config["personalities"][self.config["active_personality_id"]],
'created_at': self.connections[client_id]["current_discussion"].current_message.created_at,
'finished_generating_at': self.connections[client_id]["current_discussion"].current_message.finished_generating_at,
}, room=client_id
)
2023-08-17 23:29:53 +00:00
def update_message(self, client_id, chunk,
parameters=None,
metadata=[],
msg_type:MSG_TYPE=None
):
2023-08-02 23:07:29 +00:00
self.connections[client_id]["current_discussion"].current_message.finished_generating_at=datetime.now().strftime('%Y-%m-%d %H:%M:%S')
2023-08-17 23:29:53 +00:00
mtdt = json.dumps(metadata, indent=4) if metadata is not None and type(metadata)== list else metadata
2023-08-02 23:07:29 +00:00
self.socketio.emit('update_message', {
"sender": self.personality.name,
'id':self.connections[client_id]["current_discussion"].current_message.id,
'content': chunk,# self.connections[client_id]["generated_text"],
'discussion_id':self.connections[client_id]["current_discussion"].discussion_id,
'message_type': msg_type.value if msg_type is not None else MSG_TYPE.MSG_TYPE_CHUNK.value if self.nb_received_tokens>1 else MSG_TYPE.MSG_TYPE_FULL.value,
'finished_generating_at': self.connections[client_id]["current_discussion"].current_message.finished_generating_at,
2023-08-17 23:29:53 +00:00
'parameters':parameters,
'metadata':mtdt
2023-08-02 23:07:29 +00:00
}, room=client_id
)
self.socketio.sleep(0.01)
2023-08-17 23:29:53 +00:00
self.connections[client_id]["current_discussion"].update_message(self.connections[client_id]["generated_text"], new_metadata=mtdt)
2023-08-02 23:07:29 +00:00
def close_message(self, client_id):
# Send final message
self.connections[client_id]["current_discussion"].current_message.finished_generating_at=datetime.now().strftime('%Y-%m-%d %H:%M:%S')
self.socketio.emit('close_message', {
"sender": self.personality.name,
"id": self.connections[client_id]["current_discussion"].current_message.id,
"content":self.connections[client_id]["generated_text"],
'binding': self.config["binding_name"],
'model' : self.config["model_name"],
'personality':self.config["personalities"][self.config["active_personality_id"]],
'created_at': self.connections[client_id]["current_discussion"].current_message.created_at,
'finished_generating_at': self.connections[client_id]["current_discussion"].current_message.finished_generating_at,
}, room=client_id
)
2023-08-17 23:29:53 +00:00
def process_chunk(
self,
chunk,
message_type:MSG_TYPE,
parameters=None,
metadata:list=[],
client_id:int=0
):
2023-05-28 23:25:25 +00:00
"""
2023-08-16 01:47:54 +00:00
Processes a chunk of generated text
2023-05-28 23:25:25 +00:00
"""
2023-07-13 17:26:15 +00:00
2023-06-30 20:09:47 +00:00
if message_type == MSG_TYPE.MSG_TYPE_STEP:
ASCIIColors.info("--> Step:"+chunk)
2023-06-27 06:57:32 +00:00
if message_type == MSG_TYPE.MSG_TYPE_STEP_START:
ASCIIColors.info("--> Step started:"+chunk)
if message_type == MSG_TYPE.MSG_TYPE_STEP_END:
2023-08-17 23:29:53 +00:00
if parameters['status']:
2023-07-29 00:41:09 +00:00
ASCIIColors.success("--> Step ended:"+chunk)
else:
ASCIIColors.error("--> Step ended:"+chunk)
2023-06-27 06:57:32 +00:00
if message_type == MSG_TYPE.MSG_TYPE_EXCEPTION:
2023-08-02 23:07:29 +00:00
self.notify(chunk,False, client_id)
2023-06-27 06:57:32 +00:00
ASCIIColors.error("--> Exception from personality:"+chunk)
2023-08-03 09:48:13 +00:00
if message_type == MSG_TYPE.MSG_TYPE_WARNING:
self.notify(chunk,True, client_id)
ASCIIColors.error("--> Exception from personality:"+chunk)
2023-08-03 15:16:17 +00:00
if message_type == MSG_TYPE.MSG_TYPE_INFO:
self.notify(chunk,True, client_id)
ASCIIColors.info("--> Info:"+chunk)
2023-07-31 01:14:05 +00:00
2023-07-29 00:41:09 +00:00
if message_type == MSG_TYPE.MSG_TYPE_NEW_MESSAGE:
2023-08-02 23:07:29 +00:00
self.nb_received_tokens = 0
2023-08-17 23:29:53 +00:00
self.new_message(
client_id,
self.personality.name,
chunk,
metadata = parameters["metadata"],
message_type= MSG_TYPE(parameters["type"]))
2023-08-02 23:07:29 +00:00
2023-07-31 01:14:05 +00:00
elif message_type == MSG_TYPE.MSG_TYPE_FINISHED_MESSAGE:
2023-08-02 23:07:29 +00:00
self.close_message(client_id)
2023-07-29 00:41:09 +00:00
elif message_type == MSG_TYPE.MSG_TYPE_CHUNK:
2023-07-13 23:42:29 +00:00
self.connections[client_id]["generated_text"] += chunk
2023-07-05 01:32:51 +00:00
self.nb_received_tokens += 1
2023-07-07 22:15:34 +00:00
ASCIIColors.green(f"Received {self.nb_received_tokens} tokens",end="\r")
sys.stdout = sys.__stdout__
sys.stdout.flush()
2023-07-21 15:01:08 +00:00
antiprompt = self.personality.detect_antiprompt(self.connections[client_id]["generated_text"])
if antiprompt:
2023-07-23 23:25:05 +00:00
ASCIIColors.warning(f"\nDetected hallucination with antiprompt: {antiprompt}")
2023-07-21 15:01:08 +00:00
self.connections[client_id]["generated_text"] = self.remove_text_from_string(self.connections[client_id]["generated_text"],antiprompt)
2023-08-17 23:29:53 +00:00
self.update_message(client_id, self.connections[client_id]["generated_text"], parameters, metadata,MSG_TYPE.MSG_TYPE_FULL)
2023-06-21 22:43:59 +00:00
return False
2023-07-21 15:01:08 +00:00
else:
2023-08-02 23:07:29 +00:00
self.update_message(client_id, chunk, metadata)
2023-07-21 15:01:08 +00:00
# if stop generation is detected then stop
if not self.cancel_gen:
return True
else:
self.cancel_gen = False
ASCIIColors.warning("Generation canceled")
return False
2023-06-21 22:43:59 +00:00
# Stream the generated text to the main process
elif message_type == MSG_TYPE.MSG_TYPE_FULL:
2023-07-13 23:42:29 +00:00
self.connections[client_id]["generated_text"] = chunk
2023-07-05 00:19:11 +00:00
self.nb_received_tokens += 1
ASCIIColors.green(f"Received {self.nb_received_tokens} tokens",end="\r",flush=True)
2023-08-17 23:29:53 +00:00
self.update_message(client_id, chunk, parameters, metadata, msg_type=message_type)
2023-06-21 22:43:59 +00:00
return True
2023-06-27 06:57:32 +00:00
# Stream the generated text to the frontend
2023-06-21 22:43:59 +00:00
else:
2023-08-17 23:29:53 +00:00
self.update_message(client_id, chunk, parameters, metadata, message_type)
2023-06-21 22:43:59 +00:00
return True
2023-07-13 23:42:29 +00:00
def generate(self, full_prompt, prompt, n_predict, client_id, callback=None):
2023-06-21 22:43:59 +00:00
if self.personality.processor is not None:
2023-08-23 21:29:42 +00:00
ASCIIColors.info("Running workflow")
2023-07-05 15:51:42 +00:00
try:
2023-07-15 18:02:03 +00:00
self.personality.processor.run_workflow( prompt, full_prompt, callback)
2023-07-05 15:51:42 +00:00
except Exception as ex:
# Catch the exception and get the traceback as a list of strings
traceback_lines = traceback.format_exception(type(ex), ex, ex.__traceback__)
# Join the traceback lines into a single string
traceback_text = ''.join(traceback_lines)
ASCIIColors.error(f"Workflow run failed.\nError:{ex}")
ASCIIColors.error(traceback_text)
2023-07-13 14:49:54 +00:00
if callback:
callback(f"Workflow run failed\nError:{ex}", MSG_TYPE.MSG_TYPE_EXCEPTION)
2023-07-05 15:51:42 +00:00
print("Finished executing the workflow")
return
2023-06-21 22:43:59 +00:00
2023-08-22 01:43:17 +00:00
2023-07-13 23:42:29 +00:00
self._generate(full_prompt, n_predict, client_id, callback)
2023-07-11 22:35:59 +00:00
ASCIIColors.success("\nFinished executing the generation")
2023-05-13 22:24:26 +00:00
2023-07-13 23:42:29 +00:00
def _generate(self, prompt, n_predict, client_id, callback=None):
2023-07-05 00:19:11 +00:00
self.nb_received_tokens = 0
2023-06-21 22:43:59 +00:00
if self.model is not None:
2023-07-11 22:35:59 +00:00
ASCIIColors.info(f"warmup for generating {n_predict} tokens")
2023-06-21 22:43:59 +00:00
if self.config["override_personality_model_parameters"]:
output = self.model.generate(
prompt,
callback=callback,
n_predict=n_predict,
temperature=self.config['temperature'],
top_k=self.config['top_k'],
top_p=self.config['top_p'],
repeat_penalty=self.config['repeat_penalty'],
repeat_last_n = self.config['repeat_last_n'],
seed=self.config['seed'],
n_threads=self.config['n_threads']
)
else:
output = self.model.generate(
prompt,
callback=callback,
2023-07-07 16:25:18 +00:00
n_predict=min(n_predict,self.personality.model_n_predicts),
2023-06-21 22:43:59 +00:00
temperature=self.personality.model_temperature,
top_k=self.personality.model_top_k,
top_p=self.personality.model_top_p,
repeat_penalty=self.personality.model_repeat_penalty,
repeat_last_n = self.personality.model_repeat_last_n,
2023-07-04 09:26:57 +00:00
seed=self.config['seed'],
2023-06-21 22:43:59 +00:00
n_threads=self.config['n_threads']
)
else:
print("No model is installed or selected. Please make sure to install a model and select it inside your configuration before attempting to communicate with the model.")
print("To do this: Install the model to your models/<binding name> folder.")
print("Then set your model information in your local configuration file that you can find in configs/local_config.yaml")
print("You can also use the ui to set your model in the settings page.")
output = ""
return output
2023-07-13 14:49:54 +00:00
def start_message_generation(self, message, message_id, client_id, is_continue=False):
2023-07-29 00:41:09 +00:00
2023-07-13 14:49:54 +00:00
ASCIIColors.info(f"Text generation requested by client: {client_id}")
2023-05-13 22:24:26 +00:00
# send the message to the bot
2023-08-02 23:07:29 +00:00
print(f"Received message : {message.content}")
if self.connections[client_id]["current_discussion"]:
2023-07-29 00:41:09 +00:00
if not self.model:
2023-08-02 23:07:29 +00:00
self.notify("No model selected. Please make sure you select a model before starting generation", False, client_id)
2023-07-29 00:41:09 +00:00
return
2023-05-13 22:24:26 +00:00
# First we need to send the new message ID to the client
2023-06-30 22:14:51 +00:00
if is_continue:
2023-08-02 23:07:29 +00:00
self.connections[client_id]["current_discussion"].load_message(message_id)
2023-08-04 22:28:36 +00:00
self.connections[client_id]["generated_text"] = message.content
2023-06-30 22:14:51 +00:00
else:
2023-08-02 23:07:29 +00:00
self.new_message(client_id, self.personality.name, "✍ please stand by ...")
2023-07-06 09:37:12 +00:00
self.socketio.sleep(0.01)
2023-05-13 22:24:26 +00:00
# prepare query and reception
2023-08-02 23:07:29 +00:00
self.discussion_messages, self.current_message, tokens = self.prepare_query(client_id, message_id, is_continue)
2023-07-13 23:42:29 +00:00
self.prepare_reception(client_id)
2023-05-28 18:36:00 +00:00
self.generating = True
2023-07-26 22:03:28 +00:00
self.connections[client_id]["processing"]=True
2023-07-13 14:49:54 +00:00
self.generate(
self.discussion_messages,
self.current_message,
2023-07-13 23:42:29 +00:00
n_predict = self.config.ctx_size-len(tokens)-1,
client_id=client_id,
2023-07-13 14:49:54 +00:00
callback=partial(self.process_chunk,client_id = client_id)
)
2023-05-13 22:24:26 +00:00
print()
2023-05-28 23:25:25 +00:00
print("## Done Generation ##")
2023-05-13 22:24:26 +00:00
print()
2023-06-18 07:06:52 +00:00
self.cancel_gen = False
2023-05-13 22:24:26 +00:00
# Send final message
2023-08-02 23:07:29 +00:00
self.close_message(client_id)
2023-07-06 09:37:12 +00:00
self.socketio.sleep(0.01)
2023-07-26 22:03:28 +00:00
self.connections[client_id]["processing"]=False
if self.connections[client_id]["schedule_for_deletion"]:
del self.connections[client_id]
2023-05-13 22:24:26 +00:00
2023-06-30 22:14:51 +00:00
ASCIIColors.success(f" ╔══════════════════════════════════════════════════╗ ")
ASCIIColors.success(f" ║ Done ║ ")
ASCIIColors.success(f" ╚══════════════════════════════════════════════════╝ ")
2023-08-19 12:06:24 +00:00
self.busy=False
2023-08-16 01:47:54 +00:00
2023-05-05 12:23:07 +00:00
else:
2023-07-19 15:41:23 +00:00
ump = self.config.discussion_prompt_separator +self.config.user_name+": " if self.config.use_user_name_in_discussions else self.personality.user_message_prefix
2023-06-30 22:14:51 +00:00
self.cancel_gen = False
2023-05-13 22:24:26 +00:00
#No discussion available
2023-06-30 22:14:51 +00:00
ASCIIColors.warning("No discussion selected!!!")
2023-08-02 23:07:29 +00:00
self.notify("No discussion selected!!!",False, client_id)
2023-05-13 22:24:26 +00:00
print()
2023-08-19 12:06:24 +00:00
self.busy=False
2023-05-13 22:24:26 +00:00
return ""