+
+"""), dummy1, dummy1, dummy1
+ else:
+ ip = get_local_ip()
+ document1 = url_path.replace('file://', f'http://{ip}:{port}/')
+ # document1 = url
+ return gr.update(visible=True, value=f""""""), dummy1, dummy1, dummy1
+ else:
+ return dummy_ret
+
+ view_document_choice.select(fn=show_doc, inputs=view_document_choice,
+ outputs=[doc_view, doc_view2, doc_view3, doc_view4])
+
+ # Get inputs to evaluate() and make_db()
+ # don't deepcopy, can contain model itself
+ all_kwargs = kwargs.copy()
+ all_kwargs.update(locals())
+
+ refresh_sources1 = functools.partial(update_and_get_source_files_given_langchain_mode,
+ **get_kwargs(update_and_get_source_files_given_langchain_mode,
+ exclude_names=['db1s', 'langchain_mode', 'chunk',
+ 'chunk_size'],
+ **all_kwargs))
+ eventdb9 = refresh_sources_btn.click(fn=refresh_sources1,
+ inputs=[my_db_state, langchain_mode, chunk, chunk_size],
+ outputs=sources_text,
+ api_name='refresh_sources' if allow_api else None)
+
+ def check_admin_pass(x):
+ return gr.update(visible=x == admin_pass)
+
+ def close_admin(x):
+ return gr.update(visible=not (x == admin_pass))
+
+ admin_pass_textbox.submit(check_admin_pass, inputs=admin_pass_textbox, outputs=system_row, queue=False) \
+ .then(close_admin, inputs=admin_pass_textbox, outputs=admin_row, queue=False)
+
+ def add_langchain_mode(db1s, selection_docs_state1, langchain_mode1, y):
+ for k in db1s:
+ set_userid(db1s[k])
+ langchain_modes = selection_docs_state1['langchain_modes']
+ langchain_mode_paths = selection_docs_state1['langchain_mode_paths']
+ visible_langchain_modes = selection_docs_state1['visible_langchain_modes']
+
+ user_path = None
+ valid = True
+ y2 = y.strip().replace(' ', '').split(',')
+ if len(y2) >= 1:
+ langchain_mode2 = y2[0]
+ if len(langchain_mode2) >= 3 and langchain_mode2.isalnum():
+ # real restriction is:
+ # ValueError: Expected collection name that (1) contains 3-63 characters, (2) starts and ends with an alphanumeric character, (3) otherwise contains only alphanumeric characters, underscores or hyphens (-), (4) contains no two consecutive periods (..) and (5) is not a valid IPv4 address, got me
+ # but just make simpler
+ user_path = y2[1] if len(y2) > 1 else None # assume scratch if don't have user_path
+ if user_path in ['', "''"]:
+ # for scratch spaces
+ user_path = None
+ if langchain_mode2 in langchain_modes_intrinsic:
+ user_path = None
+ textbox = "Invalid access to use internal name: %s" % langchain_mode2
+ valid = False
+ langchain_mode2 = langchain_mode1
+ elif user_path and allow_upload_to_user_data or not user_path and allow_upload_to_my_data:
+ langchain_mode_paths.update({langchain_mode2: user_path})
+ if langchain_mode2 not in visible_langchain_modes:
+ visible_langchain_modes.append(langchain_mode2)
+ if langchain_mode2 not in langchain_modes:
+ langchain_modes.append(langchain_mode2)
+ textbox = ''
+ if user_path:
+ makedirs(user_path, exist_ok=True)
+ else:
+ valid = False
+ langchain_mode2 = langchain_mode1
+ textbox = "Invalid access. user allowed: %s " \
+ "scratch allowed: %s" % (allow_upload_to_user_data, allow_upload_to_my_data)
+ else:
+ valid = False
+ langchain_mode2 = langchain_mode1
+ textbox = "Invalid, collection must be >=3 characters and alphanumeric"
+ else:
+ valid = False
+ langchain_mode2 = langchain_mode1
+ textbox = "Invalid, must be like UserData2, user_path2"
+ selection_docs_state1 = update_langchain_mode_paths(db1s, selection_docs_state1)
+ df_langchain_mode_paths1 = get_df_langchain_mode_paths(selection_docs_state1)
+ choices = get_langchain_choices(selection_docs_state1)
+
+ if valid and not user_path:
+ # needs to have key for it to make it known different from userdata case in _update_user_db()
+ db1s[langchain_mode2] = [None, None]
+ if valid:
+ save_collection_names(langchain_modes, visible_langchain_modes, langchain_mode_paths, LangChainMode,
+ db1s)
+
+ return db1s, selection_docs_state1, gr.update(choices=choices,
+ value=langchain_mode2), textbox, df_langchain_mode_paths1
+
+ def remove_langchain_mode(db1s, selection_docs_state1, langchain_mode1, langchain_mode2, dbsu=None):
+ for k in db1s:
+ set_userid(db1s[k])
+ assert dbsu is not None
+ langchain_modes = selection_docs_state1['langchain_modes']
+ langchain_mode_paths = selection_docs_state1['langchain_mode_paths']
+ visible_langchain_modes = selection_docs_state1['visible_langchain_modes']
+
+ if langchain_mode2 in db1s and not allow_upload_to_my_data or \
+ dbsu is not None and langchain_mode2 in dbsu and not allow_upload_to_user_data or \
+ langchain_mode2 in langchain_modes_intrinsic:
+ # NOTE: Doesn't fail if remove MyData, but didn't debug odd behavior seen with upload after gone
+ textbox = "Invalid access, cannot remove %s" % langchain_mode2
+ df_langchain_mode_paths1 = get_df_langchain_mode_paths(selection_docs_state1)
+ else:
+ # change global variables
+ if langchain_mode2 in visible_langchain_modes:
+ visible_langchain_modes.remove(langchain_mode2)
+ textbox = ""
+ else:
+ textbox = "%s was not visible" % langchain_mode2
+ if langchain_mode2 in langchain_modes:
+ langchain_modes.remove(langchain_mode2)
+ if langchain_mode2 in langchain_mode_paths:
+ langchain_mode_paths.pop(langchain_mode2)
+ if langchain_mode2 in db1s:
+ # remove db entirely, so not in list, else need to manage visible list in update_langchain_mode_paths()
+ # FIXME: Remove location?
+ if langchain_mode2 != LangChainMode.MY_DATA.value:
+ # don't remove last MyData, used as user hash
+ db1s.pop(langchain_mode2)
+ # only show
+ selection_docs_state1 = update_langchain_mode_paths(db1s, selection_docs_state1)
+ df_langchain_mode_paths1 = get_df_langchain_mode_paths(selection_docs_state1)
+
+ save_collection_names(langchain_modes, visible_langchain_modes, langchain_mode_paths, LangChainMode,
+ db1s)
+
+ return db1s, selection_docs_state1, \
+ gr.update(choices=get_langchain_choices(selection_docs_state1),
+ value=langchain_mode2), textbox, df_langchain_mode_paths1
+
+ new_langchain_mode_text.submit(fn=add_langchain_mode,
+ inputs=[my_db_state, selection_docs_state, langchain_mode,
+ new_langchain_mode_text],
+ outputs=[my_db_state, selection_docs_state, langchain_mode,
+ new_langchain_mode_text,
+ langchain_mode_path_text],
+ api_name='new_langchain_mode_text' if allow_api and allow_upload_to_user_data else None)
+ remove_langchain_mode_func = functools.partial(remove_langchain_mode, dbsu=dbs)
+ remove_langchain_mode_text.submit(fn=remove_langchain_mode_func,
+ inputs=[my_db_state, selection_docs_state, langchain_mode,
+ remove_langchain_mode_text],
+ outputs=[my_db_state, selection_docs_state, langchain_mode,
+ remove_langchain_mode_text,
+ langchain_mode_path_text],
+ api_name='remove_langchain_mode_text' if allow_api and allow_upload_to_user_data else None)
+
+ def update_langchain_gr(db1s, selection_docs_state1, langchain_mode1):
+ for k in db1s:
+ set_userid(db1s[k])
+ langchain_modes = selection_docs_state1['langchain_modes']
+ langchain_mode_paths = selection_docs_state1['langchain_mode_paths']
+ visible_langchain_modes = selection_docs_state1['visible_langchain_modes']
+ # in-place
+
+ # update user collaborative collections
+ update_langchain(langchain_modes, visible_langchain_modes, langchain_mode_paths, '')
+ # update scratch single-user collections
+ user_hash = db1s.get(LangChainMode.MY_DATA.value, '')[1]
+ update_langchain(langchain_modes, visible_langchain_modes, langchain_mode_paths, user_hash)
+
+ selection_docs_state1 = update_langchain_mode_paths(db1s, selection_docs_state1)
+ df_langchain_mode_paths1 = get_df_langchain_mode_paths(selection_docs_state1)
+ return selection_docs_state1, \
+ gr.update(choices=get_langchain_choices(selection_docs_state1),
+ value=langchain_mode1), df_langchain_mode_paths1
+
+ load_langchain.click(fn=update_langchain_gr,
+ inputs=[my_db_state, selection_docs_state, langchain_mode],
+ outputs=[selection_docs_state, langchain_mode, langchain_mode_path_text],
+ api_name='load_langchain' if allow_api and allow_upload_to_user_data else None)
+
+ inputs_list, inputs_dict = get_inputs_list(all_kwargs, kwargs['model_lower'], model_id=1)
+ inputs_list2, inputs_dict2 = get_inputs_list(all_kwargs, kwargs['model_lower'], model_id=2)
+ from functools import partial
+ kwargs_evaluate = {k: v for k, v in all_kwargs.items() if k in inputs_kwargs_list}
+ # ensure present
+ for k in inputs_kwargs_list:
+ assert k in kwargs_evaluate, "Missing %s" % k
+
+ def evaluate_nochat(*args1, default_kwargs1=None, str_api=False, **kwargs1):
+ args_list = list(args1)
+ if str_api:
+ user_kwargs = args_list[len(input_args_list)]
+ assert isinstance(user_kwargs, str)
+ user_kwargs = ast.literal_eval(user_kwargs)
+ else:
+ user_kwargs = {k: v for k, v in zip(eval_func_param_names, args_list[len(input_args_list):])}
+ # only used for submit_nochat_api
+ user_kwargs['chat'] = False
+ if 'stream_output' not in user_kwargs:
+ user_kwargs['stream_output'] = False
+ if 'langchain_mode' not in user_kwargs:
+ # if user doesn't specify, then assume disabled, not use default
+ user_kwargs['langchain_mode'] = 'Disabled'
+ if 'langchain_action' not in user_kwargs:
+ user_kwargs['langchain_action'] = LangChainAction.QUERY.value
+ if 'langchain_agents' not in user_kwargs:
+ user_kwargs['langchain_agents'] = []
+
+ set1 = set(list(default_kwargs1.keys()))
+ set2 = set(eval_func_param_names)
+ assert set1 == set2, "Set diff: %s %s: %s" % (set1, set2, set1.symmetric_difference(set2))
+ # correct ordering. Note some things may not be in default_kwargs, so can't be default of user_kwargs.get()
+ model_state1 = args_list[0]
+ my_db_state1 = args_list[1]
+ selection_docs_state1 = args_list[2]
+ args_list = [user_kwargs[k] if k in user_kwargs and user_kwargs[k] is not None else default_kwargs1[k] for k
+ in eval_func_param_names]
+ assert len(args_list) == len(eval_func_param_names)
+ args_list = [model_state1, my_db_state1, selection_docs_state1] + args_list
+
+ try:
+ for res_dict in evaluate(*tuple(args_list), **kwargs1):
+ if str_api:
+ # full return of dict
+ yield res_dict
+ elif kwargs['langchain_mode'] == 'Disabled':
+ yield fix_text_for_gradio(res_dict['response'])
+ else:
+ yield '
' + fix_text_for_gradio(res_dict['response'])
+ finally:
+ clear_torch_cache()
+ clear_embeddings(user_kwargs['langchain_mode'], my_db_state1)
+
+ fun = partial(evaluate_nochat,
+ default_kwargs1=default_kwargs,
+ str_api=False,
+ **kwargs_evaluate)
+ fun2 = partial(evaluate_nochat,
+ default_kwargs1=default_kwargs,
+ str_api=False,
+ **kwargs_evaluate)
+ fun_with_dict_str = partial(evaluate_nochat,
+ default_kwargs1=default_kwargs,
+ str_api=True,
+ **kwargs_evaluate
+ )
+
+ dark_mode_btn.click(
+ None,
+ None,
+ None,
+ _js=get_dark_js(),
+ api_name="dark" if allow_api else None,
+ queue=False,
+ )
+
+ def visible_toggle(x):
+ x = 'off' if x == 'on' else 'on'
+ return x, gr.Column.update(visible=True if x == 'on' else False)
+
+ side_bar_btn.click(fn=visible_toggle,
+ inputs=side_bar_text,
+ outputs=[side_bar_text, side_bar],
+ queue=False)
+
+ submit_buttons_btn.click(fn=visible_toggle,
+ inputs=submit_buttons_text,
+ outputs=[submit_buttons_text, submit_buttons],
+ queue=False)
+
+ # examples after submit or any other buttons for chat or no chat
+ if kwargs['examples'] is not None and kwargs['show_examples']:
+ gr.Examples(examples=kwargs['examples'], inputs=inputs_list)
+
+ # Score
+ def score_last_response(*args, nochat=False, num_model_lock=0):
+ try:
+ if num_model_lock > 0:
+ # then lock way
+ args_list = list(args).copy()
+ outputs = args_list[-num_model_lock:]
+ score_texts1 = []
+ for output in outputs:
+ # same input, put into form good for _score_last_response()
+ args_list[-1] = output
+ score_texts1.append(
+ _score_last_response(*tuple(args_list), nochat=nochat,
+ num_model_lock=num_model_lock, prefix=''))
+ if len(score_texts1) > 1:
+ return "Response Scores: %s" % ' '.join(score_texts1)
+ else:
+ return "Response Scores: %s" % score_texts1[0]
+ else:
+ return _score_last_response(*args, nochat=nochat, num_model_lock=num_model_lock)
+ finally:
+ clear_torch_cache()
+
+ def _score_last_response(*args, nochat=False, num_model_lock=0, prefix='Response Score: '):
+ """ Similar to user() """
+ args_list = list(args)
+ smodel = score_model_state0['model']
+ stokenizer = score_model_state0['tokenizer']
+ sdevice = score_model_state0['device']
+
+ if memory_restriction_level > 0:
+ max_length_tokenize = 768 - 256 if memory_restriction_level <= 2 else 512 - 256
+ elif hasattr(stokenizer, 'model_max_length'):
+ max_length_tokenize = stokenizer.model_max_length
+ else:
+ # limit to 1024, not worth OOMing on reward score
+ max_length_tokenize = 2048 - 1024
+ cutoff_len = max_length_tokenize * 4 # restrict deberta related to max for LLM
+
+ if not nochat:
+ history = args_list[-1]
+ if history is None:
+ history = []
+ if smodel is not None and \
+ stokenizer is not None and \
+ sdevice is not None and \
+ history is not None and len(history) > 0 and \
+ history[-1] is not None and \
+ len(history[-1]) >= 2:
+ os.environ['TOKENIZERS_PARALLELISM'] = 'false'
+
+ question = history[-1][0]
+
+ answer = history[-1][1]
+ else:
+ return '%sNA' % prefix
+ else:
+ answer = args_list[-1]
+ instruction_nochat_arg_id = eval_func_param_names.index('instruction_nochat')
+ question = args_list[instruction_nochat_arg_id]
+
+ if question is None:
+ return '%sBad Question' % prefix
+ if answer is None:
+ return '%sBad Answer' % prefix
+ try:
+ score = score_qa(smodel, stokenizer, max_length_tokenize, question, answer, cutoff_len)
+ finally:
+ clear_torch_cache()
+ if isinstance(score, str):
+ return '%sNA' % prefix
+ return '{}{:.1%}'.format(prefix, score)
+
+ def noop_score_last_response(*args, **kwargs):
+ return "Response Score: Disabled"
+
+ if kwargs['score_model']:
+ score_fun = score_last_response
+ else:
+ score_fun = noop_score_last_response
+
+ score_args = dict(fn=score_fun,
+ inputs=inputs_list + [text_output],
+ outputs=[score_text],
+ )
+ score_args2 = dict(fn=partial(score_fun),
+ inputs=inputs_list2 + [text_output2],
+ outputs=[score_text2],
+ )
+ score_fun_func = functools.partial(score_fun, num_model_lock=len(text_outputs))
+ all_score_args = dict(fn=score_fun_func,
+ inputs=inputs_list + text_outputs,
+ outputs=score_text,
+ )
+
+ score_args_nochat = dict(fn=partial(score_fun, nochat=True),
+ inputs=inputs_list + [text_output_nochat],
+ outputs=[score_text_nochat],
+ )
+
+ def update_history(*args, undo=False, retry=False, sanitize_user_prompt=False):
+ """
+ User that fills history for bot
+ :param args:
+ :param undo:
+ :param retry:
+ :param sanitize_user_prompt:
+ :return:
+ """
+ args_list = list(args)
+ user_message = args_list[eval_func_param_names.index('instruction')] # chat only
+ input1 = args_list[eval_func_param_names.index('iinput')] # chat only
+ prompt_type1 = args_list[eval_func_param_names.index('prompt_type')]
+ langchain_mode1 = args_list[eval_func_param_names.index('langchain_mode')]
+ langchain_action1 = args_list[eval_func_param_names.index('langchain_action')]
+ langchain_agents1 = args_list[eval_func_param_names.index('langchain_agents')]
+ document_subset1 = args_list[eval_func_param_names.index('document_subset')]
+ document_choice1 = args_list[eval_func_param_names.index('document_choice')]
+ if not prompt_type1:
+ # shouldn't have to specify if CLI launched model
+ prompt_type1 = kwargs['prompt_type']
+ # apply back
+ args_list[eval_func_param_names.index('prompt_type')] = prompt_type1
+ if input1 and not user_message.endswith(':'):
+ user_message1 = user_message + ":" + input1
+ elif input1:
+ user_message1 = user_message + input1
+ else:
+ user_message1 = user_message
+ if sanitize_user_prompt:
+ from better_profanity import profanity
+ user_message1 = profanity.censor(user_message1)
+
+ history = args_list[-1]
+ if history is None:
+ # bad history
+ history = []
+ history = history.copy()
+
+ if undo:
+ if len(history) > 0:
+ history.pop()
+ return history
+ if retry:
+ if history:
+ history[-1][1] = None
+ return history
+ if user_message1 in ['', None, '\n']:
+ if not allow_empty_instruction(langchain_mode1, document_subset1, langchain_action1):
+ # reject non-retry submit/enter
+ return history
+ user_message1 = fix_text_for_gradio(user_message1)
+ return history + [[user_message1, None]]
+
+ def user(*args, undo=False, retry=False, sanitize_user_prompt=False):
+ return update_history(*args, undo=undo, retry=retry, sanitize_user_prompt=sanitize_user_prompt)
+
+ def all_user(*args, undo=False, retry=False, sanitize_user_prompt=False, num_model_lock=0):
+ args_list = list(args)
+ history_list = args_list[-num_model_lock:]
+ assert len(history_list) > 0, "Bad history list: %s" % history_list
+ for hi, history in enumerate(history_list):
+ if num_model_lock > 0:
+ hargs = args_list[:-num_model_lock].copy()
+ else:
+ hargs = args_list.copy()
+ hargs += [history]
+ history_list[hi] = update_history(*hargs, undo=undo, retry=retry,
+ sanitize_user_prompt=sanitize_user_prompt)
+ if len(history_list) > 1:
+ return tuple(history_list)
+ else:
+ return history_list[0]
+
+ def get_model_max_length(model_state1):
+ if model_state1 and not isinstance(model_state1["tokenizer"], str):
+ tokenizer = model_state1["tokenizer"]
+ elif model_state0 and not isinstance(model_state0["tokenizer"], str):
+ tokenizer = model_state0["tokenizer"]
+ else:
+ tokenizer = None
+ if tokenizer is not None:
+ return tokenizer.model_max_length
+ else:
+ return 2000
+
+ def prep_bot(*args, retry=False, which_model=0):
+ """
+
+ :param args:
+ :param retry:
+ :param which_model: identifies which model if doing model_lock
+ API only called for which_model=0, default for inputs_list, but rest should ignore inputs_list
+ :return: last element is True if should run bot, False if should just yield history
+ """
+ isize = len(input_args_list) + 1 # states + chat history
+ # don't deepcopy, can contain model itself
+ args_list = list(args).copy()
+ model_state1 = args_list[-isize]
+ my_db_state1 = args_list[-isize + 1]
+ selection_docs_state1 = args_list[-isize + 2]
+ history = args_list[-1]
+ prompt_type1 = args_list[eval_func_param_names.index('prompt_type')]
+ prompt_dict1 = args_list[eval_func_param_names.index('prompt_dict')]
+
+ if model_state1['model'] is None or model_state1['model'] == no_model_str:
+ return history, None, None, None
+
+ args_list = args_list[:-isize] # only keep rest needed for evaluate()
+ langchain_mode1 = args_list[eval_func_param_names.index('langchain_mode')]
+ add_chat_history_to_context1 = args_list[eval_func_param_names.index('add_chat_history_to_context')]
+ langchain_action1 = args_list[eval_func_param_names.index('langchain_action')]
+ langchain_agents1 = args_list[eval_func_param_names.index('langchain_agents')]
+ document_subset1 = args_list[eval_func_param_names.index('document_subset')]
+ document_choice1 = args_list[eval_func_param_names.index('document_choice')]
+ if not history:
+ print("No history", flush=True)
+ history = []
+ return history, None, None, None
+ instruction1 = history[-1][0]
+ if retry and history:
+ # if retry, pop history and move onto bot stuff
+ instruction1 = history[-1][0]
+ history[-1][1] = None
+ elif not instruction1:
+ if not allow_empty_instruction(langchain_mode1, document_subset1, langchain_action1):
+ # if not retrying, then reject empty query
+ return history, None, None, None
+ elif len(history) > 0 and history[-1][1] not in [None, '']:
+ # reject submit button if already filled and not retrying
+ # None when not filling with '' to keep client happy
+ return history, None, None, None
+
+ # shouldn't have to specify in API prompt_type if CLI launched model, so prefer global CLI one if have it
+ prompt_type1, prompt_dict1 = update_prompt(prompt_type1, prompt_dict1, model_state1,
+ which_model=which_model)
+ # apply back to args_list for evaluate()
+ args_list[eval_func_param_names.index('prompt_type')] = prompt_type1
+ args_list[eval_func_param_names.index('prompt_dict')] = prompt_dict1
+
+ chat1 = args_list[eval_func_param_names.index('chat')]
+ model_max_length1 = get_model_max_length(model_state1)
+ context1 = history_to_context(history, langchain_mode1,
+ add_chat_history_to_context1,
+ prompt_type1, prompt_dict1, chat1,
+ model_max_length1, memory_restriction_level,
+ kwargs['keep_sources_in_context'])
+ args_list[0] = instruction1 # override original instruction with history from user
+ args_list[2] = context1
+
+ fun1 = partial(evaluate,
+ model_state1,
+ my_db_state1,
+ selection_docs_state1,
+ *tuple(args_list),
+ **kwargs_evaluate)
+
+ return history, fun1, langchain_mode1, my_db_state1
+
+ def get_response(fun1, history):
+ """
+ bot that consumes history for user input
+ instruction (from input_list) itself is not consumed by bot
+ :return:
+ """
+ if not fun1:
+ yield history, ''
+ return
+ try:
+ for output_fun in fun1():
+ output = output_fun['response']
+ extra = output_fun['sources'] # FIXME: can show sources in separate text box etc.
+ # ensure good visually, else markdown ignores multiple \n
+ bot_message = fix_text_for_gradio(output)
+ history[-1][1] = bot_message
+ yield history, ''
+ except StopIteration:
+ yield history, ''
+ except RuntimeError as e:
+ if "generator raised StopIteration" in str(e):
+ # assume last entry was bad, undo
+ history.pop()
+ yield history, ''
+ else:
+ if history and len(history) > 0 and len(history[0]) > 1 and history[-1][1] is None:
+ history[-1][1] = ''
+ yield history, str(e)
+ raise
+ except Exception as e:
+ # put error into user input
+ ex = "Exception: %s" % str(e)
+ if history and len(history) > 0 and len(history[0]) > 1 and history[-1][1] is None:
+ history[-1][1] = ''
+ yield history, ex
+ raise
+ finally:
+ clear_torch_cache()
+ return
+
+ def clear_embeddings(langchain_mode1, db1s):
+ # clear any use of embedding that sits on GPU, else keeps accumulating GPU usage even if clear torch cache
+ if db_type == 'chroma' and langchain_mode1 not in ['LLM', 'Disabled', None, '']:
+ from gpt_langchain import clear_embedding
+ db = dbs.get('langchain_mode1')
+ if db is not None and not isinstance(db, str):
+ clear_embedding(db)
+ if db1s is not None and langchain_mode1 in db1s:
+ db1 = db1s[langchain_mode1]
+ if len(db1) == 2:
+ clear_embedding(db1[0])
+
+ def bot(*args, retry=False):
+ history, fun1, langchain_mode1, db1 = prep_bot(*args, retry=retry)
+ try:
+ for res in get_response(fun1, history):
+ yield res
+ finally:
+ clear_torch_cache()
+ clear_embeddings(langchain_mode1, db1)
+
+ def all_bot(*args, retry=False, model_states1=None):
+ args_list = list(args).copy()
+ chatbots = args_list[-len(model_states1):]
+ args_list0 = args_list[:-len(model_states1)] # same for all models
+ exceptions = []
+ stream_output1 = args_list[eval_func_param_names.index('stream_output')]
+ max_time1 = args_list[eval_func_param_names.index('max_time')]
+ langchain_mode1 = args_list[eval_func_param_names.index('langchain_mode')]
+ isize = len(input_args_list) + 1 # states + chat history
+ db1s = None
+ try:
+ gen_list = []
+ for chatboti, (chatbot1, model_state1) in enumerate(zip(chatbots, model_states1)):
+ args_list1 = args_list0.copy()
+ args_list1.insert(-isize + 2,
+ model_state1) # insert at -2 so is at -3, and after chatbot1 added, at -4
+ # if at start, have None in response still, replace with '' so client etc. acts like normal
+ # assumes other parts of code treat '' and None as if no response yet from bot
+ # can't do this later in bot code as racy with threaded generators
+ if len(chatbot1) > 0 and len(chatbot1[-1]) == 2 and chatbot1[-1][1] is None:
+ chatbot1[-1][1] = ''
+ args_list1.append(chatbot1)
+ # so consistent with prep_bot()
+ # with model_state1 at -3, my_db_state1 at -2, and history(chatbot) at -1
+ # langchain_mode1 and my_db_state1 should be same for every bot
+ history, fun1, langchain_mode1, db1s = prep_bot(*tuple(args_list1), retry=retry,
+ which_model=chatboti)
+ gen1 = get_response(fun1, history)
+ if stream_output1:
+ gen1 = TimeoutIterator(gen1, timeout=0.01, sentinel=None, raise_on_exception=False)
+ # else timeout will truncate output for non-streaming case
+ gen_list.append(gen1)
+
+ bots_old = chatbots.copy()
+ exceptions_old = [''] * len(bots_old)
+ tgen0 = time.time()
+ for res1 in itertools.zip_longest(*gen_list):
+ if time.time() - tgen0 > max_time1:
+ print("Took too long: %s" % max_time1, flush=True)
+ break
+
+ bots = [x[0] if x is not None and not isinstance(x, BaseException) else y for x, y in
+ zip(res1, bots_old)]
+ bots_old = bots.copy()
+
+ def larger_str(x, y):
+ return x if len(x) > len(y) else y
+
+ exceptions = [x[1] if x is not None and not isinstance(x, BaseException) else larger_str(str(x), y)
+ for x, y in zip(res1, exceptions_old)]
+ exceptions_old = exceptions.copy()
+
+ def choose_exc(x):
+ # don't expose ports etc. to exceptions window
+ if is_public:
+ return "Endpoint unavailable or failed"
+ else:
+ return x
+
+ exceptions_str = '\n'.join(
+ ['Model %s: %s' % (iix, choose_exc(x)) for iix, x in enumerate(exceptions) if
+ x not in [None, '', 'None']])
+ if len(bots) > 1:
+ yield tuple(bots + [exceptions_str])
+ else:
+ yield bots[0], exceptions_str
+ if exceptions:
+ exceptions = [x for x in exceptions if x not in ['', None, 'None']]
+ if exceptions:
+ print("Generate exceptions: %s" % exceptions, flush=True)
+ finally:
+ clear_torch_cache()
+ clear_embeddings(langchain_mode1, db1s)
+
+ # NORMAL MODEL
+ user_args = dict(fn=functools.partial(user, sanitize_user_prompt=kwargs['sanitize_user_prompt']),
+ inputs=inputs_list + [text_output],
+ outputs=text_output,
+ )
+ bot_args = dict(fn=bot,
+ inputs=inputs_list + [model_state, my_db_state, selection_docs_state] + [text_output],
+ outputs=[text_output, chat_exception_text],
+ )
+ retry_bot_args = dict(fn=functools.partial(bot, retry=True),
+ inputs=inputs_list + [model_state, my_db_state, selection_docs_state] + [text_output],
+ outputs=[text_output, chat_exception_text],
+ )
+ retry_user_args = dict(fn=functools.partial(user, retry=True),
+ inputs=inputs_list + [text_output],
+ outputs=text_output,
+ )
+ undo_user_args = dict(fn=functools.partial(user, undo=True),
+ inputs=inputs_list + [text_output],
+ outputs=text_output,
+ )
+
+ # MODEL2
+ user_args2 = dict(fn=functools.partial(user, sanitize_user_prompt=kwargs['sanitize_user_prompt']),
+ inputs=inputs_list2 + [text_output2],
+ outputs=text_output2,
+ )
+ bot_args2 = dict(fn=bot,
+ inputs=inputs_list2 + [model_state2, my_db_state, selection_docs_state] + [text_output2],
+ outputs=[text_output2, chat_exception_text],
+ )
+ retry_bot_args2 = dict(fn=functools.partial(bot, retry=True),
+ inputs=inputs_list2 + [model_state2, my_db_state, selection_docs_state] + [text_output2],
+ outputs=[text_output2, chat_exception_text],
+ )
+ retry_user_args2 = dict(fn=functools.partial(user, retry=True),
+ inputs=inputs_list2 + [text_output2],
+ outputs=text_output2,
+ )
+ undo_user_args2 = dict(fn=functools.partial(user, undo=True),
+ inputs=inputs_list2 + [text_output2],
+ outputs=text_output2,
+ )
+
+ # MODEL N
+ all_user_args = dict(fn=functools.partial(all_user,
+ sanitize_user_prompt=kwargs['sanitize_user_prompt'],
+ num_model_lock=len(text_outputs),
+ ),
+ inputs=inputs_list + text_outputs,
+ outputs=text_outputs,
+ )
+ all_bot_args = dict(fn=functools.partial(all_bot, model_states1=model_states),
+ inputs=inputs_list + [my_db_state, selection_docs_state] + text_outputs,
+ outputs=text_outputs + [chat_exception_text],
+ )
+ all_retry_bot_args = dict(fn=functools.partial(all_bot, model_states1=model_states, retry=True),
+ inputs=inputs_list + [my_db_state, selection_docs_state] + text_outputs,
+ outputs=text_outputs + [chat_exception_text],
+ )
+ all_retry_user_args = dict(fn=functools.partial(all_user, retry=True,
+ sanitize_user_prompt=kwargs['sanitize_user_prompt'],
+ num_model_lock=len(text_outputs),
+ ),
+ inputs=inputs_list + text_outputs,
+ outputs=text_outputs,
+ )
+ all_undo_user_args = dict(fn=functools.partial(all_user, undo=True,
+ sanitize_user_prompt=kwargs['sanitize_user_prompt'],
+ num_model_lock=len(text_outputs),
+ ),
+ inputs=inputs_list + text_outputs,
+ outputs=text_outputs,
+ )
+
+ def clear_instruct():
+ return gr.Textbox.update(value='')
+
+ def deselect_radio_chats():
+ return gr.update(value=None)
+
+ def clear_all():
+ return gr.Textbox.update(value=''), gr.Textbox.update(value=''), gr.update(value=None), \
+ gr.Textbox.update(value=''), gr.Textbox.update(value='')
+
+ if kwargs['model_states']:
+ submits1 = submits2 = submits3 = []
+ submits4 = []
+
+ fun_source = [instruction.submit, submit.click, retry_btn.click]
+ fun_name = ['instruction', 'submit', 'retry']
+ user_args = [all_user_args, all_user_args, all_retry_user_args]
+ bot_args = [all_bot_args, all_bot_args, all_retry_bot_args]
+ for userargs1, botarg1, funn1, funs1 in zip(user_args, bot_args, fun_name, fun_source):
+ submit_event11 = funs1(fn=dummy_fun,
+ inputs=instruction, outputs=instruction, queue=queue)
+ submit_event1a = submit_event11.then(**userargs1, queue=queue,
+ api_name='%s' % funn1 if allow_api else None)
+ # if hit enter on new instruction for submitting new query, no longer the saved chat
+ submit_event1b = submit_event1a.then(clear_all, inputs=None,
+ outputs=[instruction, iinput, radio_chats, score_text,
+ score_text2],
+ queue=queue)
+ submit_event1c = submit_event1b.then(**botarg1,
+ api_name='%s_bot' % funn1 if allow_api else None,
+ queue=queue)
+ submit_event1d = submit_event1c.then(**all_score_args,
+ api_name='%s_bot_score' % funn1 if allow_api else None,
+ queue=queue)
+
+ submits1.extend([submit_event1a, submit_event1b, submit_event1c, submit_event1d])
+
+ # if undo, no longer the saved chat
+ submit_event4 = undo.click(fn=dummy_fun,
+ inputs=instruction, outputs=instruction, queue=queue) \
+ .then(**all_undo_user_args, api_name='undo' if allow_api else None) \
+ .then(clear_all, inputs=None, outputs=[instruction, iinput, radio_chats, score_text,
+ score_text2], queue=queue) \
+ .then(**all_score_args, api_name='undo_score' if allow_api else None)
+ submits4 = [submit_event4]
+
+ else:
+ # in case 2nd model, consume instruction first, so can clear quickly
+ # bot doesn't consume instruction itself, just history from user, so why works
+ submit_event11 = instruction.submit(fn=dummy_fun,
+ inputs=instruction, outputs=instruction, queue=queue)
+ submit_event1a = submit_event11.then(**user_args, queue=queue,
+ api_name='instruction' if allow_api else None)
+ # if hit enter on new instruction for submitting new query, no longer the saved chat
+ submit_event1a2 = submit_event1a.then(deselect_radio_chats, inputs=None, outputs=radio_chats, queue=queue)
+ submit_event1b = submit_event1a2.then(**user_args2, api_name='instruction2' if allow_api else None)
+ submit_event1c = submit_event1b.then(clear_instruct, None, instruction) \
+ .then(clear_instruct, None, iinput)
+ submit_event1d = submit_event1c.then(**bot_args, api_name='instruction_bot' if allow_api else None,
+ queue=queue)
+ submit_event1e = submit_event1d.then(**score_args,
+ api_name='instruction_bot_score' if allow_api else None,
+ queue=queue)
+ submit_event1f = submit_event1e.then(**bot_args2, api_name='instruction_bot2' if allow_api else None,
+ queue=queue)
+ submit_event1g = submit_event1f.then(**score_args2,
+ api_name='instruction_bot_score2' if allow_api else None, queue=queue)
+
+ submits1 = [submit_event1a, submit_event1a2, submit_event1b, submit_event1c, submit_event1d,
+ submit_event1e,
+ submit_event1f, submit_event1g]
+
+ submit_event21 = submit.click(fn=dummy_fun,
+ inputs=instruction, outputs=instruction, queue=queue)
+ submit_event2a = submit_event21.then(**user_args, api_name='submit' if allow_api else None)
+ # if submit new query, no longer the saved chat
+ submit_event2a2 = submit_event2a.then(deselect_radio_chats, inputs=None, outputs=radio_chats, queue=queue)
+ submit_event2b = submit_event2a2.then(**user_args2, api_name='submit2' if allow_api else None)
+ submit_event2c = submit_event2b.then(clear_all, inputs=None,
+ outputs=[instruction, iinput, radio_chats, score_text, score_text2],
+ queue=queue)
+ submit_event2d = submit_event2c.then(**bot_args, api_name='submit_bot' if allow_api else None, queue=queue)
+ submit_event2e = submit_event2d.then(**score_args,
+ api_name='submit_bot_score' if allow_api else None,
+ queue=queue)
+ submit_event2f = submit_event2e.then(**bot_args2, api_name='submit_bot2' if allow_api else None,
+ queue=queue)
+ submit_event2g = submit_event2f.then(**score_args2,
+ api_name='submit_bot_score2' if allow_api else None,
+ queue=queue)
+
+ submits2 = [submit_event2a, submit_event2a2, submit_event2b, submit_event2c, submit_event2d,
+ submit_event2e,
+ submit_event2f, submit_event2g]
+
+ submit_event31 = retry_btn.click(fn=dummy_fun,
+ inputs=instruction, outputs=instruction, queue=queue)
+ submit_event3a = submit_event31.then(**user_args, api_name='retry' if allow_api else None)
+ # if retry, no longer the saved chat
+ submit_event3a2 = submit_event3a.then(deselect_radio_chats, inputs=None, outputs=radio_chats, queue=queue)
+ submit_event3b = submit_event3a2.then(**user_args2, api_name='retry2' if allow_api else None)
+ submit_event3c = submit_event3b.then(clear_instruct, None, instruction) \
+ .then(clear_instruct, None, iinput)
+ submit_event3d = submit_event3c.then(**retry_bot_args, api_name='retry_bot' if allow_api else None,
+ queue=queue)
+ submit_event3e = submit_event3d.then(**score_args,
+ api_name='retry_bot_score' if allow_api else None,
+ queue=queue)
+ submit_event3f = submit_event3e.then(**retry_bot_args2, api_name='retry_bot2' if allow_api else None,
+ queue=queue)
+ submit_event3g = submit_event3f.then(**score_args2,
+ api_name='retry_bot_score2' if allow_api else None,
+ queue=queue)
+
+ submits3 = [submit_event3a, submit_event3a2, submit_event3b, submit_event3c, submit_event3d,
+ submit_event3e,
+ submit_event3f, submit_event3g]
+
+ # if undo, no longer the saved chat
+ submit_event4 = undo.click(fn=dummy_fun,
+ inputs=instruction, outputs=instruction, queue=queue) \
+ .then(**undo_user_args, api_name='undo' if allow_api else None) \
+ .then(**undo_user_args2, api_name='undo2' if allow_api else None) \
+ .then(clear_all, inputs=None, outputs=[instruction, iinput, radio_chats, score_text,
+ score_text2], queue=queue) \
+ .then(**score_args, api_name='undo_score' if allow_api else None) \
+ .then(**score_args2, api_name='undo_score2' if allow_api else None)
+ submits4 = [submit_event4]
+
+ # MANAGE CHATS
+ def dedup(short_chat, short_chats):
+ if short_chat not in short_chats:
+ return short_chat
+ for i in range(1, 1000):
+ short_chat_try = short_chat + "_" + str(i)
+ if short_chat_try not in short_chats:
+ return short_chat_try
+ # fallback and hope for best
+ short_chat = short_chat + "_" + str(random.random())
+ return short_chat
+
+ def get_short_chat(x, short_chats, short_len=20, words=4):
+ if x and len(x[0]) == 2 and x[0][0] is not None:
+ short_chat = ' '.join(x[0][0][:short_len].split(' ')[:words]).strip()
+ if not short_chat:
+ # e.g.summarization, try using answer
+ short_chat = ' '.join(x[0][1][:short_len].split(' ')[:words]).strip()
+ if not short_chat:
+ short_chat = 'Unk'
+ short_chat = dedup(short_chat, short_chats)
+ else:
+ short_chat = None
+ return short_chat
+
+ def is_chat_same(x, y):
+ # etc. added in chat, try to remove some of that to help avoid dup entries when hit new conversation
+ is_same = True
+ # length of conversation has to be same
+ if len(x) != len(y):
+ return False
+ if len(x) != len(y):
+ return False
+ for stepx, stepy in zip(x, y):
+ if len(stepx) != len(stepy):
+ # something off with a conversation
+ return False
+ for stepxx, stepyy in zip(stepx, stepy):
+ if len(stepxx) != len(stepyy):
+ # something off with a conversation
+ return False
+ if len(stepxx) != 2:
+ # something off
+ return False
+ if len(stepyy) != 2:
+ # something off
+ return False
+ questionx = stepxx[0].replace('
', '').replace('
', '') if stepxx[0] is not None else None
+ answerx = stepxx[1].replace('', '').replace('
', '') if stepxx[1] is not None else None
+
+ questiony = stepyy[0].replace('', '').replace('
', '') if stepyy[0] is not None else None
+ answery = stepyy[1].replace('', '').replace('
', '') if stepyy[1] is not None else None
+
+ if questionx != questiony or answerx != answery:
+ return False
+ return is_same
+
+ def save_chat(*args, chat_is_list=False):
+ args_list = list(args)
+ if not chat_is_list:
+ # list of chatbot histories,
+ # can't pass in list with list of chatbot histories and state due to gradio limits
+ chat_list = args_list[:-1]
+ else:
+ assert len(args_list) == 2
+ chat_list = args_list[0]
+ # if old chat file with single chatbot, get into shape
+ if isinstance(chat_list, list) and len(chat_list) > 0 and isinstance(chat_list[0], list) and len(
+ chat_list[0]) == 2 and isinstance(chat_list[0][0], str) and isinstance(chat_list[0][1], str):
+ chat_list = [chat_list]
+ # remove None histories
+ chat_list_not_none = [x for x in chat_list if x and len(x) > 0 and len(x[0]) == 2 and x[0][1] is not None]
+ chat_list_none = [x for x in chat_list if x not in chat_list_not_none]
+ if len(chat_list_none) > 0 and len(chat_list_not_none) == 0:
+ raise ValueError("Invalid chat file")
+ # dict with keys of short chat names, values of list of list of chatbot histories
+ chat_state1 = args_list[-1]
+ short_chats = list(chat_state1.keys())
+ if len(chat_list_not_none) > 0:
+ # make short_chat key from only first history, based upon question that is same anyways
+ chat_first = chat_list_not_none[0]
+ short_chat = get_short_chat(chat_first, short_chats)
+ if short_chat:
+ old_chat_lists = list(chat_state1.values())
+ already_exists = any([is_chat_same(chat_list, x) for x in old_chat_lists])
+ if not already_exists:
+ chat_state1[short_chat] = chat_list.copy()
+
+ # reverse so newest at top
+ choices = list(chat_state1.keys()).copy()
+ choices.reverse()
+
+ return chat_state1, gr.update(choices=choices, value=None)
+
+ def switch_chat(chat_key, chat_state1, num_model_lock=0):
+ chosen_chat = chat_state1[chat_key]
+ # deal with possible different size of chat list vs. current list
+ ret_chat = [None] * (2 + num_model_lock)
+ for chati in range(0, 2 + num_model_lock):
+ ret_chat[chati % len(ret_chat)] = chosen_chat[chati % len(chosen_chat)]
+ return tuple(ret_chat)
+
+ def clear_texts(*args):
+ return tuple([gr.Textbox.update(value='')] * len(args))
+
+ def clear_scores():
+ return gr.Textbox.update(value=res_value), \
+ gr.Textbox.update(value='Response Score: NA'), \
+ gr.Textbox.update(value='Response Score: NA')
+
+ switch_chat_fun = functools.partial(switch_chat, num_model_lock=len(text_outputs))
+ radio_chats.input(switch_chat_fun,
+ inputs=[radio_chats, chat_state],
+ outputs=[text_output, text_output2] + text_outputs) \
+ .then(clear_scores, outputs=[score_text, score_text2, score_text_nochat])
+
+ def remove_chat(chat_key, chat_state1):
+ if isinstance(chat_key, str):
+ chat_state1.pop(chat_key, None)
+ return gr.update(choices=list(chat_state1.keys()), value=None), chat_state1
+
+ remove_chat_event = remove_chat_btn.click(remove_chat,
+ inputs=[radio_chats, chat_state], outputs=[radio_chats, chat_state],
+ queue=False, api_name='remove_chat')
+
+ def get_chats1(chat_state1):
+ base = 'chats'
+ makedirs(base, exist_ok=True)
+ filename = os.path.join(base, 'chats_%s.json' % str(uuid.uuid4()))
+ with open(filename, "wt") as f:
+ f.write(json.dumps(chat_state1, indent=2))
+ return filename
+
+ export_chat_event = export_chats_btn.click(get_chats1, inputs=chat_state, outputs=chats_file, queue=False,
+ api_name='export_chats' if allow_api else None)
+
+ def add_chats_from_file(file, chat_state1, radio_chats1, chat_exception_text1):
+ if not file:
+ return None, chat_state1, gr.update(choices=list(chat_state1.keys()), value=None), chat_exception_text1
+ if isinstance(file, str):
+ files = [file]
+ else:
+ files = file
+ if not files:
+ return None, chat_state1, gr.update(choices=list(chat_state1.keys()), value=None), chat_exception_text1
+ chat_exception_list = []
+ for file1 in files:
+ try:
+ if hasattr(file1, 'name'):
+ file1 = file1.name
+ with open(file1, "rt") as f:
+ new_chats = json.loads(f.read())
+ for chat1_k, chat1_v in new_chats.items():
+ # ignore chat1_k, regenerate and de-dup to avoid loss
+ chat_state1, _ = save_chat(chat1_v, chat_state1, chat_is_list=True)
+ except BaseException as e:
+ t, v, tb = sys.exc_info()
+ ex = ''.join(traceback.format_exception(t, v, tb))
+ ex_str = "File %s exception: %s" % (file1, str(e))
+ print(ex_str, flush=True)
+ chat_exception_list.append(ex_str)
+ chat_exception_text1 = '\n'.join(chat_exception_list)
+ return None, chat_state1, gr.update(choices=list(chat_state1.keys()), value=None), chat_exception_text1
+
+ # note for update_user_db_func output is ignored for db
+ chatup_change_event = chatsup_output.change(add_chats_from_file,
+ inputs=[chatsup_output, chat_state, radio_chats,
+ chat_exception_text],
+ outputs=[chatsup_output, chat_state, radio_chats,
+ chat_exception_text],
+ queue=False,
+ api_name='add_to_chats' if allow_api else None)
+
+ clear_chat_event = clear_chat_btn.click(fn=clear_texts,
+ inputs=[text_output, text_output2] + text_outputs,
+ outputs=[text_output, text_output2] + text_outputs,
+ queue=False, api_name='clear' if allow_api else None) \
+ .then(deselect_radio_chats, inputs=None, outputs=radio_chats, queue=False) \
+ .then(clear_scores, outputs=[score_text, score_text2, score_text_nochat])
+
+ clear_event = save_chat_btn.click(save_chat,
+ inputs=[text_output, text_output2] + text_outputs + [chat_state],
+ outputs=[chat_state, radio_chats],
+ api_name='save_chat' if allow_api else None)
+ if kwargs['score_model']:
+ clear_event2 = clear_event.then(clear_scores, outputs=[score_text, score_text2, score_text_nochat])
+
+ # NOTE: clear of instruction/iinput for nochat has to come after score,
+ # because score for nochat consumes actual textbox, while chat consumes chat history filled by user()
+ no_chat_args = dict(fn=fun,
+ inputs=[model_state, my_db_state, selection_docs_state] + inputs_list,
+ outputs=text_output_nochat,
+ queue=queue,
+ )
+ submit_event_nochat = submit_nochat.click(**no_chat_args, api_name='submit_nochat' if allow_api else None) \
+ .then(clear_torch_cache) \
+ .then(**score_args_nochat, api_name='instruction_bot_score_nochat' if allow_api else None, queue=queue) \
+ .then(clear_instruct, None, instruction_nochat) \
+ .then(clear_instruct, None, iinput_nochat) \
+ .then(clear_torch_cache)
+ # copy of above with text box submission
+ submit_event_nochat2 = instruction_nochat.submit(**no_chat_args) \
+ .then(clear_torch_cache) \
+ .then(**score_args_nochat, queue=queue) \
+ .then(clear_instruct, None, instruction_nochat) \
+ .then(clear_instruct, None, iinput_nochat) \
+ .then(clear_torch_cache)
+
+ submit_event_nochat_api = submit_nochat_api.click(fun_with_dict_str,
+ inputs=[model_state, my_db_state, selection_docs_state,
+ inputs_dict_str],
+ outputs=text_output_nochat_api,
+ queue=True, # required for generator
+ api_name='submit_nochat_api' if allow_api else None) \
+ .then(clear_torch_cache)
+
+ def load_model(model_name, lora_weights, server_name, model_state_old, prompt_type_old, load_8bit,
+ use_gpu_id, gpu_id):
+ # ensure no API calls reach here
+ if is_public:
+ raise RuntimeError("Illegal access for %s" % model_name)
+ # ensure old model removed from GPU memory
+ if kwargs['debug']:
+ print("Pre-switch pre-del GPU memory: %s" % get_torch_allocated(), flush=True)
+
+ model0 = model_state0['model']
+ if isinstance(model_state_old['model'], str) and model0 is not None:
+ # best can do, move model loaded at first to CPU
+ model0.cpu()
+
+ if model_state_old['model'] is not None and not isinstance(model_state_old['model'], str):
+ try:
+ model_state_old['model'].cpu()
+ except Exception as e:
+ # sometimes hit NotImplementedError: Cannot copy out of meta tensor; no data!
+ print("Unable to put model on CPU: %s" % str(e), flush=True)
+ del model_state_old['model']
+ model_state_old['model'] = None
+
+ if model_state_old['tokenizer'] is not None and not isinstance(model_state_old['tokenizer'], str):
+ del model_state_old['tokenizer']
+ model_state_old['tokenizer'] = None
+
+ clear_torch_cache()
+ if kwargs['debug']:
+ print("Pre-switch post-del GPU memory: %s" % get_torch_allocated(), flush=True)
+
+ if model_name is None or model_name == no_model_str:
+ # no-op if no model, just free memory
+ # no detranscribe needed for model, never go into evaluate
+ lora_weights = no_lora_str
+ server_name = no_server_str
+ return [None, None, None, model_name, server_name], \
+ model_name, lora_weights, server_name, prompt_type_old, \
+ gr.Slider.update(maximum=256), \
+ gr.Slider.update(maximum=256)
+
+ # don't deepcopy, can contain model itself
+ all_kwargs1 = all_kwargs.copy()
+ all_kwargs1['base_model'] = model_name.strip()
+ all_kwargs1['load_8bit'] = load_8bit
+ all_kwargs1['use_gpu_id'] = use_gpu_id
+ all_kwargs1['gpu_id'] = int(gpu_id) # detranscribe
+ model_lower = model_name.strip().lower()
+ if model_lower in inv_prompt_type_to_model_lower:
+ prompt_type1 = inv_prompt_type_to_model_lower[model_lower]
+ else:
+ prompt_type1 = prompt_type_old
+
+ # detranscribe
+ if lora_weights == no_lora_str:
+ lora_weights = ''
+ all_kwargs1['lora_weights'] = lora_weights.strip()
+ if server_name == no_server_str:
+ server_name = ''
+ all_kwargs1['inference_server'] = server_name.strip()
+
+ model1, tokenizer1, device1 = get_model(reward_type=False,
+ **get_kwargs(get_model, exclude_names=['reward_type'],
+ **all_kwargs1))
+ clear_torch_cache()
+
+ tokenizer_base_model = model_name
+ prompt_dict1, error0 = get_prompt(prompt_type1, '',
+ chat=False, context='', reduced=False, making_context=False,
+ return_dict=True)
+ model_state_new = dict(model=model1, tokenizer=tokenizer1, device=device1,
+ base_model=model_name, tokenizer_base_model=tokenizer_base_model,
+ lora_weights=lora_weights, inference_server=server_name,
+ prompt_type=prompt_type1, prompt_dict=prompt_dict1,
+ )
+
+ max_max_new_tokens1 = get_max_max_new_tokens(model_state_new, **kwargs)
+
+ if kwargs['debug']:
+ print("Post-switch GPU memory: %s" % get_torch_allocated(), flush=True)
+ return model_state_new, model_name, lora_weights, server_name, prompt_type1, \
+ gr.Slider.update(maximum=max_max_new_tokens1), \
+ gr.Slider.update(maximum=max_max_new_tokens1)
+
+ def get_prompt_str(prompt_type1, prompt_dict1, which=0):
+ if prompt_type1 in ['', None]:
+ print("Got prompt_type %s: %s" % (which, prompt_type1), flush=True)
+ return str({})
+ prompt_dict1, prompt_dict_error = get_prompt(prompt_type1, prompt_dict1, chat=False, context='',
+ reduced=False, making_context=False, return_dict=True)
+ if prompt_dict_error:
+ return str(prompt_dict_error)
+ else:
+ # return so user can manipulate if want and use as custom
+ return str(prompt_dict1)
+
+ get_prompt_str_func1 = functools.partial(get_prompt_str, which=1)
+ get_prompt_str_func2 = functools.partial(get_prompt_str, which=2)
+ prompt_type.change(fn=get_prompt_str_func1, inputs=[prompt_type, prompt_dict], outputs=prompt_dict, queue=False)
+ prompt_type2.change(fn=get_prompt_str_func2, inputs=[prompt_type2, prompt_dict2], outputs=prompt_dict2,
+ queue=False)
+
+ def dropdown_prompt_type_list(x):
+ return gr.Dropdown.update(value=x)
+
+ def chatbot_list(x, model_used_in):
+ return gr.Textbox.update(label=f'h2oGPT [Model: {model_used_in}]')
+
+ load_model_args = dict(fn=load_model,
+ inputs=[model_choice, lora_choice, server_choice, model_state, prompt_type,
+ model_load8bit_checkbox, model_use_gpu_id_checkbox, model_gpu],
+ outputs=[model_state, model_used, lora_used, server_used,
+ # if prompt_type changes, prompt_dict will change via change rule
+ prompt_type, max_new_tokens, min_new_tokens,
+ ])
+ prompt_update_args = dict(fn=dropdown_prompt_type_list, inputs=prompt_type, outputs=prompt_type)
+ chatbot_update_args = dict(fn=chatbot_list, inputs=[text_output, model_used], outputs=text_output)
+ nochat_update_args = dict(fn=chatbot_list, inputs=[text_output_nochat, model_used], outputs=text_output_nochat)
+ load_model_event = load_model_button.click(**load_model_args,
+ api_name='load_model' if allow_api and is_public else None) \
+ .then(**prompt_update_args) \
+ .then(**chatbot_update_args) \
+ .then(**nochat_update_args) \
+ .then(clear_torch_cache)
+
+ load_model_args2 = dict(fn=load_model,
+ inputs=[model_choice2, lora_choice2, server_choice2, model_state2, prompt_type2,
+ model_load8bit_checkbox2, model_use_gpu_id_checkbox2, model_gpu2],
+ outputs=[model_state2, model_used2, lora_used2, server_used2,
+ # if prompt_type2 changes, prompt_dict2 will change via change rule
+ prompt_type2, max_new_tokens2, min_new_tokens2
+ ])
+ prompt_update_args2 = dict(fn=dropdown_prompt_type_list, inputs=prompt_type2, outputs=prompt_type2)
+ chatbot_update_args2 = dict(fn=chatbot_list, inputs=[text_output2, model_used2], outputs=text_output2)
+ load_model_event2 = load_model_button2.click(**load_model_args2,
+ api_name='load_model2' if allow_api and is_public else None) \
+ .then(**prompt_update_args2) \
+ .then(**chatbot_update_args2) \
+ .then(clear_torch_cache)
+
+ def dropdown_model_lora_server_list(model_list0, model_x,
+ lora_list0, lora_x,
+ server_list0, server_x,
+ model_used1, lora_used1, server_used1,
+ model_used2, lora_used2, server_used2,
+ ):
+ model_new_state = [model_list0[0] + [model_x]]
+ model_new_options = [*model_new_state[0]]
+ x1 = model_x if model_used1 == no_model_str else model_used1
+ x2 = model_x if model_used2 == no_model_str else model_used2
+ ret1 = [gr.Dropdown.update(value=x1, choices=model_new_options),
+ gr.Dropdown.update(value=x2, choices=model_new_options),
+ '', model_new_state]
+
+ lora_new_state = [lora_list0[0] + [lora_x]]
+ lora_new_options = [*lora_new_state[0]]
+ # don't switch drop-down to added lora if already have model loaded
+ x1 = lora_x if model_used1 == no_model_str else lora_used1
+ x2 = lora_x if model_used2 == no_model_str else lora_used2
+ ret2 = [gr.Dropdown.update(value=x1, choices=lora_new_options),
+ gr.Dropdown.update(value=x2, choices=lora_new_options),
+ '', lora_new_state]
+
+ server_new_state = [server_list0[0] + [server_x]]
+ server_new_options = [*server_new_state[0]]
+ # don't switch drop-down to added server if already have model loaded
+ x1 = server_x if model_used1 == no_model_str else server_used1
+ x2 = server_x if model_used2 == no_model_str else server_used2
+ ret3 = [gr.Dropdown.update(value=x1, choices=server_new_options),
+ gr.Dropdown.update(value=x2, choices=server_new_options),
+ '', server_new_state]
+
+ return tuple(ret1 + ret2 + ret3)
+
+ add_model_lora_server_event = \
+ add_model_lora_server_button.click(fn=dropdown_model_lora_server_list,
+ inputs=[model_options_state, new_model] +
+ [lora_options_state, new_lora] +
+ [server_options_state, new_server] +
+ [model_used, lora_used, server_used] +
+ [model_used2, lora_used2, server_used2],
+ outputs=[model_choice, model_choice2, new_model, model_options_state] +
+ [lora_choice, lora_choice2, new_lora, lora_options_state] +
+ [server_choice, server_choice2, new_server,
+ server_options_state],
+ queue=False)
+
+ go_event = go_btn.click(lambda: gr.update(visible=False), None, go_btn, api_name="go" if allow_api else None,
+ queue=False) \
+ .then(lambda: gr.update(visible=True), None, normal_block, queue=False) \
+ .then(**load_model_args, queue=False).then(**prompt_update_args, queue=False)
+
+ def compare_textbox_fun(x):
+ return gr.Textbox.update(visible=x)
+
+ def compare_column_fun(x):
+ return gr.Column.update(visible=x)
+
+ def compare_prompt_fun(x):
+ return gr.Dropdown.update(visible=x)
+
+ def slider_fun(x):
+ return gr.Slider.update(visible=x)
+
+ compare_checkbox.select(compare_textbox_fun, compare_checkbox, text_output2,
+ api_name="compare_checkbox" if allow_api else None) \
+ .then(compare_column_fun, compare_checkbox, col_model2) \
+ .then(compare_prompt_fun, compare_checkbox, prompt_type2) \
+ .then(compare_textbox_fun, compare_checkbox, score_text2) \
+ .then(slider_fun, compare_checkbox, max_new_tokens2) \
+ .then(slider_fun, compare_checkbox, min_new_tokens2)
+ # FIXME: add score_res2 in condition, but do better
+
+ # callback for logging flagged input/output
+ callback.setup(inputs_list + [text_output, text_output2] + text_outputs, "flagged_data_points")
+ flag_btn.click(lambda *args: callback.flag(args), inputs_list + [text_output, text_output2] + text_outputs,
+ None,
+ preprocess=False,
+ api_name='flag' if allow_api else None, queue=False)
+ flag_btn_nochat.click(lambda *args: callback.flag(args), inputs_list + [text_output_nochat], None,
+ preprocess=False,
+ api_name='flag_nochat' if allow_api else None, queue=False)
+
+ def get_system_info():
+ if is_public:
+ time.sleep(10) # delay to avoid spam since queue=False
+ return gr.Textbox.update(value=system_info_print())
+
+ system_event = system_btn.click(get_system_info, outputs=system_text,
+ api_name='system_info' if allow_api else None, queue=False)
+
+ def get_system_info_dict(system_input1, **kwargs1):
+ if system_input1 != os.getenv("ADMIN_PASS", ""):
+ return json.dumps({})
+ exclude_list = ['admin_pass', 'examples']
+ sys_dict = {k: v for k, v in kwargs1.items() if
+ isinstance(v, (str, int, bool, float)) and k not in exclude_list}
+ try:
+ sys_dict.update(system_info())
+ except Exception as e:
+ # protection
+ print("Exception: %s" % str(e), flush=True)
+ return json.dumps(sys_dict)
+
+ system_kwargs = all_kwargs.copy()
+ system_kwargs.update(dict(command=str(' '.join(sys.argv))))
+ get_system_info_dict_func = functools.partial(get_system_info_dict, **all_kwargs)
+
+ system_dict_event = system_btn2.click(get_system_info_dict_func,
+ inputs=system_input,
+ outputs=system_text2,
+ api_name='system_info_dict' if allow_api else None,
+ queue=False, # queue to avoid spam
+ )
+
+ def get_hash():
+ return kwargs['git_hash']
+
+ system_event = system_btn3.click(get_hash,
+ outputs=system_text3,
+ api_name='system_hash' if allow_api else None,
+ queue=False,
+ )
+
+ def count_chat_tokens(model_state1, chat1, prompt_type1, prompt_dict1,
+ memory_restriction_level1=0,
+ keep_sources_in_context1=False,
+ ):
+ if model_state1 and not isinstance(model_state1['tokenizer'], str):
+ tokenizer = model_state1['tokenizer']
+ elif model_state0 and not isinstance(model_state0['tokenizer'], str):
+ tokenizer = model_state0['tokenizer']
+ else:
+ tokenizer = None
+ if tokenizer is not None:
+ langchain_mode1 = 'LLM'
+ add_chat_history_to_context1 = True
+ # fake user message to mimic bot()
+ chat1 = copy.deepcopy(chat1)
+ chat1 = chat1 + [['user_message1', None]]
+ model_max_length1 = tokenizer.model_max_length
+ context1 = history_to_context(chat1, langchain_mode1,
+ add_chat_history_to_context1,
+ prompt_type1, prompt_dict1, chat1,
+ model_max_length1,
+ memory_restriction_level1, keep_sources_in_context1)
+ return str(tokenizer(context1, return_tensors="pt")['input_ids'].shape[1])
+ else:
+ return "N/A"
+
+ count_chat_tokens_func = functools.partial(count_chat_tokens,
+ memory_restriction_level1=memory_restriction_level,
+ keep_sources_in_context1=kwargs['keep_sources_in_context'])
+ count_tokens_event = count_chat_tokens_btn.click(fn=count_chat_tokens,
+ inputs=[model_state, text_output, prompt_type, prompt_dict],
+ outputs=chat_token_count,
+ api_name='count_tokens' if allow_api else None)
+
+ # don't pass text_output, don't want to clear output, just stop it
+ # cancel only stops outer generation, not inner generation or non-generation
+ stop_btn.click(lambda: None, None, None,
+ cancels=submits1 + submits2 + submits3 + submits4 +
+ [submit_event_nochat, submit_event_nochat2] +
+ [eventdb1, eventdb2, eventdb3] +
+ [eventdb7, eventdb8, eventdb9, eventdb12] +
+ db_events +
+ [clear_event] +
+ [submit_event_nochat_api, submit_event_nochat] +
+ [load_model_event, load_model_event2] +
+ [count_tokens_event]
+ ,
+ queue=False, api_name='stop' if allow_api else None).then(clear_torch_cache, queue=False)
+
+ demo.load(None, None, None, _js=get_dark_js() if kwargs['dark'] else None)
+
+ demo.queue(concurrency_count=kwargs['concurrency_count'], api_open=kwargs['api_open'])
+ favicon_path = "h2o-logo.svg"
+ if not os.path.isfile(favicon_path):
+ print("favicon_path=%s not found" % favicon_path, flush=True)
+ favicon_path = None
+
+ scheduler = BackgroundScheduler()
+ scheduler.add_job(func=clear_torch_cache, trigger="interval", seconds=20)
+ if is_public and \
+ kwargs['base_model'] not in non_hf_types:
+ # FIXME: disable for gptj, langchain or gpt4all modify print itself
+ # FIXME: and any multi-threaded/async print will enter model output!
+ scheduler.add_job(func=ping, trigger="interval", seconds=60)
+ if is_public or os.getenv('PING_GPU'):
+ scheduler.add_job(func=ping_gpu, trigger="interval", seconds=60 * 10)
+ scheduler.start()
+
+ # import control
+ if kwargs['langchain_mode'] == 'Disabled' and \
+ os.environ.get("TEST_LANGCHAIN_IMPORT") and \
+ kwargs['base_model'] not in non_hf_types:
+ assert 'gpt_langchain' not in sys.modules, "Dev bug, import of langchain when should not have"
+ assert 'langchain' not in sys.modules, "Dev bug, import of langchain when should not have"
+
+ demo.launch(share=kwargs['share'], server_name="0.0.0.0", show_error=True,
+ favicon_path=favicon_path, prevent_thread_lock=True,
+ auth=kwargs['auth'])
+ if kwargs['verbose']:
+ print("Started GUI", flush=True)
+ if kwargs['block_gradio_exit']:
+ demo.block_thread()
+
+
+def get_inputs_list(inputs_dict, model_lower, model_id=1):
+ """
+ map gradio objects in locals() to inputs for evaluate().
+ :param inputs_dict:
+ :param model_lower:
+ :param model_id: Which model (1 or 2) of 2
+ :return:
+ """
+ inputs_list_names = list(inspect.signature(evaluate).parameters)
+ inputs_list = []
+ inputs_dict_out = {}
+ for k in inputs_list_names:
+ if k == 'kwargs':
+ continue
+ if k in input_args_list + inputs_kwargs_list:
+ # these are added at use time for args or partial for kwargs, not taken as input
+ continue
+ if 'mbart-' not in model_lower and k in ['src_lang', 'tgt_lang']:
+ continue
+ if model_id == 2:
+ if k == 'prompt_type':
+ k = 'prompt_type2'
+ if k == 'prompt_used':
+ k = 'prompt_used2'
+ if k == 'max_new_tokens':
+ k = 'max_new_tokens2'
+ if k == 'min_new_tokens':
+ k = 'min_new_tokens2'
+ inputs_list.append(inputs_dict[k])
+ inputs_dict_out[k] = inputs_dict[k]
+ return inputs_list, inputs_dict_out
+
+
+def get_sources(db1s, langchain_mode, dbs=None, docs_state0=None):
+ for k in db1s:
+ set_userid(db1s[k])
+
+ if langchain_mode in ['LLM']:
+ source_files_added = "NA"
+ source_list = []
+ elif langchain_mode in ['wiki_full']:
+ source_files_added = "Not showing wiki_full, takes about 20 seconds and makes 4MB file." \
+ " Ask jon.mckinney@h2o.ai for file if required."
+ source_list = []
+ elif langchain_mode in db1s and len(db1s[langchain_mode]) == 2 and db1s[langchain_mode][0] is not None:
+ db1 = db1s[langchain_mode]
+ from gpt_langchain import get_metadatas
+ metadatas = get_metadatas(db1[0])
+ source_list = sorted(set([x['source'] for x in metadatas]))
+ source_files_added = '\n'.join(source_list)
+ elif langchain_mode in dbs and dbs[langchain_mode] is not None:
+ from gpt_langchain import get_metadatas
+ db1 = dbs[langchain_mode]
+ metadatas = get_metadatas(db1)
+ source_list = sorted(set([x['source'] for x in metadatas]))
+ source_files_added = '\n'.join(source_list)
+ else:
+ source_list = []
+ source_files_added = "None"
+ sources_dir = "sources_dir"
+ makedirs(sources_dir)
+ sources_file = os.path.join(sources_dir, 'sources_%s_%s' % (langchain_mode, str(uuid.uuid4())))
+ with open(sources_file, "wt") as f:
+ f.write(source_files_added)
+ source_list = docs_state0 + source_list
+ return sources_file, source_list
+
+
+def set_userid(db1):
+ # can only call this after function called so for specific userr, not in gr.State() that occurs during app init
+ assert db1 is not None and len(db1) == 2
+ if db1[1] is None:
+ # uuid in db is used as user ID
+ db1[1] = str(uuid.uuid4())
+
+
+def update_user_db(file, db1s, selection_docs_state1, chunk, chunk_size, langchain_mode, dbs=None, **kwargs):
+ kwargs.update(selection_docs_state1)
+ if file is None:
+ raise RuntimeError("Don't use change, use input")
+
+ try:
+ return _update_user_db(file, db1s=db1s, chunk=chunk, chunk_size=chunk_size,
+ langchain_mode=langchain_mode, dbs=dbs,
+ **kwargs)
+ except BaseException as e:
+ print(traceback.format_exc(), flush=True)
+ # gradio has issues if except, so fail semi-gracefully, else would hang forever in processing textbox
+ ex_str = "Exception: %s" % str(e)
+ source_files_added = """\
+
+
+
+ Sources:
+
+
+ {0}
+
+
+
+ """.format(ex_str)
+ doc_exception_text = str(e)
+ return None, langchain_mode, source_files_added, doc_exception_text
+ finally:
+ clear_torch_cache()
+
+
+def get_lock_file(db1, langchain_mode):
+ set_userid(db1)
+ assert len(db1) == 2 and db1[1] is not None and isinstance(db1[1], str)
+ user_id = db1[1]
+ base_path = 'locks'
+ makedirs(base_path)
+ lock_file = os.path.join(base_path, "db_%s_%s.lock" % (langchain_mode.replace(' ', '_'), user_id))
+ return lock_file
+
+
+def _update_user_db(file,
+ db1s=None,
+ chunk=None, chunk_size=None,
+ dbs=None, db_type=None,
+ langchain_mode='UserData',
+ langchain_modes=None, # unused but required as part of selection_docs_state1
+ langchain_mode_paths=None,
+ visible_langchain_modes=None,
+ use_openai_embedding=None,
+ hf_embedding_model=None,
+ caption_loader=None,
+ enable_captions=None,
+ captions_model=None,
+ enable_ocr=None,
+ enable_pdf_ocr=None,
+ verbose=None,
+ n_jobs=-1,
+ is_url=None, is_txt=None,
+ ):
+ assert db1s is not None
+ assert chunk is not None
+ assert chunk_size is not None
+ assert use_openai_embedding is not None
+ assert hf_embedding_model is not None
+ assert caption_loader is not None
+ assert enable_captions is not None
+ assert captions_model is not None
+ assert enable_ocr is not None
+ assert enable_pdf_ocr is not None
+ assert verbose is not None
+
+ if dbs is None:
+ dbs = {}
+ assert isinstance(dbs, dict), "Wrong type for dbs: %s" % str(type(dbs))
+ # assert db_type in ['faiss', 'chroma'], "db_type %s not supported" % db_type
+ from gpt_langchain import add_to_db, get_db, path_to_docs
+ # handle case of list of temp buffer
+ if isinstance(file, list) and len(file) > 0 and hasattr(file[0], 'name'):
+ file = [x.name for x in file]
+ # handle single file of temp buffer
+ if hasattr(file, 'name'):
+ file = file.name
+ if not isinstance(file, (list, tuple, typing.Generator)) and isinstance(file, str):
+ file = [file]
+
+ if langchain_mode == LangChainMode.DISABLED.value:
+ return None, langchain_mode, get_source_files(), ""
+
+ if langchain_mode in [LangChainMode.LLM.value]:
+ # then switch to MyData, so langchain_mode also becomes way to select where upload goes
+ # but default to mydata if nothing chosen, since safest
+ if LangChainMode.MY_DATA.value in visible_langchain_modes:
+ langchain_mode = LangChainMode.MY_DATA.value
+
+ if langchain_mode_paths is None:
+ langchain_mode_paths = {}
+ user_path = langchain_mode_paths.get(langchain_mode)
+ # UserData or custom, which has to be from user's disk
+ if user_path is not None:
+ # move temp files from gradio upload to stable location
+ for fili, fil in enumerate(file):
+ if isinstance(fil, str) and os.path.isfile(fil): # not url, text
+ new_fil = os.path.normpath(os.path.join(user_path, os.path.basename(fil)))
+ if os.path.normpath(os.path.abspath(fil)) != os.path.normpath(os.path.abspath(new_fil)):
+ if os.path.isfile(new_fil):
+ remove(new_fil)
+ try:
+ shutil.move(fil, new_fil)
+ except FileExistsError:
+ pass
+ file[fili] = new_fil
+
+ if verbose:
+ print("Adding %s" % file, flush=True)
+ sources = path_to_docs(file if not is_url and not is_txt else None,
+ verbose=verbose,
+ n_jobs=n_jobs,
+ chunk=chunk, chunk_size=chunk_size,
+ url=file if is_url else None,
+ text=file if is_txt else None,
+ enable_captions=enable_captions,
+ captions_model=captions_model,
+ enable_ocr=enable_ocr,
+ enable_pdf_ocr=enable_pdf_ocr,
+ caption_loader=caption_loader,
+ )
+ exceptions = [x for x in sources if x.metadata.get('exception')]
+ exceptions_strs = [x.metadata['exception'] for x in exceptions]
+ sources = [x for x in sources if 'exception' not in x.metadata]
+
+ # below must at least come after langchain_mode is modified in case was LLM -> MyData,
+ # so original langchain mode changed
+ for k in db1s:
+ set_userid(db1s[k])
+ db1 = get_db1(db1s, langchain_mode)
+
+ lock_file = get_lock_file(db1s[LangChainMode.MY_DATA.value], langchain_mode) # user-level lock, not db-level lock
+ with filelock.FileLock(lock_file):
+ if langchain_mode in db1s:
+ if db1[0] is not None:
+ # then add
+ db, num_new_sources, new_sources_metadata = add_to_db(db1[0], sources, db_type=db_type,
+ use_openai_embedding=use_openai_embedding,
+ hf_embedding_model=hf_embedding_model)
+ else:
+ # in testing expect:
+ # assert len(db1) == 2 and db1[1] is None, "Bad MyData db: %s" % db1
+ # for production hit, when user gets clicky:
+ assert len(db1) == 2, "Bad %s db: %s" % (langchain_mode, db1)
+ assert db1[1] is not None, "db hash was None, not allowed"
+ # then create
+ # if added has to original state and didn't change, then would be shared db for all users
+ persist_directory = os.path.join(scratch_base_dir, 'db_dir_%s_%s' % (langchain_mode, db1[1]))
+ db = get_db(sources, use_openai_embedding=use_openai_embedding,
+ db_type=db_type,
+ persist_directory=persist_directory,
+ langchain_mode=langchain_mode,
+ hf_embedding_model=hf_embedding_model)
+ if db is not None:
+ db1[0] = db
+ source_files_added = get_source_files(db=db1[0], exceptions=exceptions)
+ return None, langchain_mode, source_files_added, '\n'.join(exceptions_strs)
+ else:
+ from gpt_langchain import get_persist_directory
+ persist_directory = get_persist_directory(langchain_mode)
+ if langchain_mode in dbs and dbs[langchain_mode] is not None:
+ # then add
+ db, num_new_sources, new_sources_metadata = add_to_db(dbs[langchain_mode], sources, db_type=db_type,
+ use_openai_embedding=use_openai_embedding,
+ hf_embedding_model=hf_embedding_model)
+ else:
+ # then create. Or might just be that dbs is unfilled, then it will fill, then add
+ db = get_db(sources, use_openai_embedding=use_openai_embedding,
+ db_type=db_type,
+ persist_directory=persist_directory,
+ langchain_mode=langchain_mode,
+ hf_embedding_model=hf_embedding_model)
+ dbs[langchain_mode] = db
+ # NOTE we do not return db, because function call always same code path
+ # return dbs[langchain_mode]
+ # db in this code path is updated in place
+ source_files_added = get_source_files(db=dbs[langchain_mode], exceptions=exceptions)
+ return None, langchain_mode, source_files_added, '\n'.join(exceptions_strs)
+
+
+def get_db(db1s, langchain_mode, dbs=None):
+ db1 = get_db1(db1s, langchain_mode)
+ lock_file = get_lock_file(db1s[LangChainMode.MY_DATA.value], langchain_mode)
+
+ with filelock.FileLock(lock_file):
+ if langchain_mode in ['wiki_full']:
+ # NOTE: avoid showing full wiki. Takes about 30 seconds over about 90k entries, but not useful for now
+ db = None
+ elif langchain_mode in db1s and len(db1) == 2 and db1[0] is not None:
+ db = db1[0]
+ elif dbs is not None and langchain_mode in dbs and dbs[langchain_mode] is not None:
+ db = dbs[langchain_mode]
+ else:
+ db = None
+ return db
+
+
+def get_source_files_given_langchain_mode(db1s, langchain_mode='UserData', dbs=None):
+ db = get_db(db1s, langchain_mode, dbs=dbs)
+ if langchain_mode in ['LLM'] or db is None:
+ return "Sources: N/A"
+ return get_source_files(db=db, exceptions=None)
+
+
+def get_source_files(db=None, exceptions=None, metadatas=None):
+ if exceptions is None:
+ exceptions = []
+
+ # only should be one source, not confused
+ # assert db is not None or metadatas is not None
+ # clicky user
+ if db is None and metadatas is None:
+ return "No Sources at all"
+
+ if metadatas is None:
+ source_label = "Sources:"
+ if db is not None:
+ from gpt_langchain import get_metadatas
+ metadatas = get_metadatas(db)
+ else:
+ metadatas = []
+ adding_new = False
+ else:
+ source_label = "New Sources:"
+ adding_new = True
+
+ # below automatically de-dups
+ from gpt_langchain import get_url
+ small_dict = {get_url(x['source'], from_str=True, short_name=True): get_short_name(x.get('head')) for x in
+ metadatas}
+ # if small_dict is empty dict, that's ok
+ df = pd.DataFrame(small_dict.items(), columns=['source', 'head'])
+ df.index = df.index + 1
+ df.index.name = 'index'
+ source_files_added = tabulate.tabulate(df, headers='keys', tablefmt='unsafehtml')
+
+ if exceptions:
+ exception_metadatas = [x.metadata for x in exceptions]
+ small_dict = {get_url(x['source'], from_str=True, short_name=True): get_short_name(x.get('exception')) for x in
+ exception_metadatas}
+ # if small_dict is empty dict, that's ok
+ df = pd.DataFrame(small_dict.items(), columns=['source', 'exception'])
+ df.index = df.index + 1
+ df.index.name = 'index'
+ exceptions_html = tabulate.tabulate(df, headers='keys', tablefmt='unsafehtml')
+ else:
+ exceptions_html = ''
+
+ if metadatas and exceptions:
+ source_files_added = """\
+
+
+
+ {0}
+
+
+ {1}
+ {2}
+
+
+
+ """.format(source_label, source_files_added, exceptions_html)
+ elif metadatas:
+ source_files_added = """\
+
+
+
+ {0}
+
+
+ {1}
+
+
+
+ """.format(source_label, source_files_added)
+ elif exceptions_html:
+ source_files_added = """\
+
+
+
+ Exceptions:
+
+
+ {0}
+
+
+
+ """.format(exceptions_html)
+ else:
+ if adding_new:
+ source_files_added = "No New Sources"
+ else:
+ source_files_added = "No Sources"
+
+ return source_files_added
+
+
+def update_and_get_source_files_given_langchain_mode(db1s, langchain_mode, chunk, chunk_size,
+ dbs=None, first_para=None,
+ text_limit=None,
+ langchain_mode_paths=None, db_type=None, load_db_if_exists=None,
+ n_jobs=None, verbose=None):
+ has_path = {k: v for k, v in langchain_mode_paths.items() if v}
+ if langchain_mode in [LangChainMode.LLM.value, LangChainMode.MY_DATA.value]:
+ # then assume user really meant UserData, to avoid extra clicks in UI,
+ # since others can't be on disk, except custom user modes, which they should then select to query it
+ if LangChainMode.USER_DATA.value in has_path:
+ langchain_mode = LangChainMode.USER_DATA.value
+
+ db = get_db(db1s, langchain_mode, dbs=dbs)
+
+ from gpt_langchain import make_db
+ db, num_new_sources, new_sources_metadata = make_db(use_openai_embedding=False,
+ hf_embedding_model="sentence-transformers/all-MiniLM-L6-v2",
+ first_para=first_para, text_limit=text_limit,
+ chunk=chunk,
+ chunk_size=chunk_size,
+ langchain_mode=langchain_mode,
+ langchain_mode_paths=langchain_mode_paths,
+ db_type=db_type,
+ load_db_if_exists=load_db_if_exists,
+ db=db,
+ n_jobs=n_jobs,
+ verbose=verbose)
+ # during refreshing, might have "created" new db since not in dbs[] yet, so insert back just in case
+ # so even if persisted, not kept up-to-date with dbs memory
+ if langchain_mode in db1s:
+ db1s[langchain_mode][0] = db
+ else:
+ dbs[langchain_mode] = db
+
+ # return only new sources with text saying such
+ return get_source_files(db=None, exceptions=None, metadatas=new_sources_metadata)
+
+
+def get_db1(db1s, langchain_mode1):
+ if langchain_mode1 in db1s:
+ db1 = db1s[langchain_mode1]
+ else:
+ # indicates to code that not scratch database
+ db1 = [None, None]
+ return db1