from textblob import TextBlob import gradio as gr import math import os os.system("python -m textblob.download_corpora") control_json={'control':'0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ','char':'','leng':62} string_json={'control':'0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMN','char':'OPQRSTUVWXYZ','leng':50} cont_list=list(string_json['control']) text=""" I asked Generative AI Models about their context window. Their response was intriguing. The context window for a large language model (LLM) like OpenAI’s GPT refers to the maximum amount of text the model can consider at any one time when generating a response. This includes both the prompt provided by the user and the model’s generated text. In practical terms, the context window limits how much previous dialogue the model can “remember” during an interaction. If the interaction exceeds the context window, the model loses access to the earliest parts of the conversation. This limitation can impact the model’s consistency in long conversations or complex tasks. I asked Generative AI Models about their context window. Their response was intriguing. The context window for a large language model (LLM) like OpenAI’s GPT refers to the maximum amount of text the model can consider at any one time when generating a response. This includes both the prompt provided by the user and the model’s generated text. In practical terms, the context window limits how much previous dialogue the model can “remember” during an interaction. If the interaction exceeds the context window, the model loses access to the earliest parts of the conversation. This limitation can impact the model’s consistency in long conversations or complex tasks. I asked Generative AI Models about their context window. Their response was intriguing. The context window for a large language model (LLM) like OpenAI’s GPT refers to the maximum amount of text the model can consider at any one time when generating a response. This includes both the prompt provided by the user and the model’s generated text. In practical terms, the context window limits how much previous dialogue the model can “remember” during an interaction. If the interaction exceeds the context window, the model loses access to the earliest parts of the conversation. This limitation can impact the model’s consistency in long conversations or complex tasks. I asked Generative AI Models about their context window. Their response was intriguing. The context window for a large language model (LLM) like OpenAI’s GPT refers to the maximum amount of text the model can consider at any one time when generating a response. This includes both the prompt provided by the user and the model’s generated text. In practical terms, the context window limits how much previous dialogue the model can “remember” during an interaction. If the interaction exceeds the context window, the model loses access to the earliest parts of the conversation. This limitation can impact the model’s consistency in long conversations or complex tasks. I asked Generative AI Models about their context window. Their response was intriguing. The context window for a large language model (LLM) like OpenAI’s GPT refers to the maximum amount of text the model can consider at any one time when generating a response. This includes both the prompt provided by the user and the model’s generated text. In practical terms, the context window limits how much previous dialogue the model can “remember” during an interaction. If the interaction exceeds the context window, the model loses access to the earliest parts of the conversation. This limitation can impact the model’s consistency in long conversations or complex tasks. """ def get_sen_list(text): sen_list=[] blob = TextBlob(text) for sentence in blob.sentences: sen_list.append(str(sentence)) return sen_list def proc_sen(sen_list,cnt): blob_n = TextBlob(sen_list[cnt]) noun_p=blob_n.noun_phrases noun_box1=[] for ea in blob_n.parse().split(" "): n=ea.split("/") if n[1] == "NN": noun_box1.append(n[0]) json_object={'sentence':sen_list[cnt],'noun_phrase':noun_p,'nouns':noun_box} return json_object def get_nouns(text=text,steps=1): control_len=control_json['leng']-steps control_char=list(control_json['control'][:control_len]) control_val=list(control_json['control'][control_len:]) char_len=len(control_char) val_len=len(control_val) print(control_char) print(control_val) json_object={} noun_list={} step_list=[] step_cont_box=[] sen_list=get_sen_list(text) key_cnt=len(sen_list) print(key_cnt) #noun_cnt=len(noun_box) #print(noun_cnt) big_cnt=0 cnt=0 go=True n_cnt=0 nx=key_cnt while True: if nx > 1: n_cnt+=1 nx = nx/char_len else: print("#######") print(n_cnt) print(nx) print("#######") steps=n_cnt break for ii in range(steps): print(ii) step_cont_box.append(0) #print (step_cont_box) mod=0 pos=len(step_cont_box)-1 if go: for i, ea in enumerate(sen_list): if go: if cnt > char_len-1: #print(step_cont_box) go1=True for ii,ev in enumerate(step_cont_box): if go: if ev >= char_len-1: step_cont_box[ii]=0 if go1==True: step_cont_box[ii-1]=step_cont_box[ii-1]+1 go1=False cnt=1 else: step_cont_box[pos]=cnt cnt+=1 print(step_cont_box) out_js="" for iii,j in enumerate(step_cont_box): print(j) out_js = out_js+control_char[j] sen_obj=proc_sen(sen_list,i) #json_out[out_js]={'nouns':ea} json_out[out_js]=sen_obj big_cnt+=1 if big_cnt==key_cnt: print("DONE") go=False return json_out,noun_list def get_nouns_OG(text,steps=1): control_len=control_json['leng']-steps control_new=control_json['control'][:control_len] control_char=control_json['control'][control_len:] print(control_new) print(control_char) json_object={} sen_list=[] noun_list={} noun_box=[] blob = TextBlob(text) for sentence in blob.sentences: sen_list.append(str(sentence)) key_cnt=len(sen_list) cnt=0 go=True a="Z" if go: for ea in range(10): if go: for b in range(50): if go: for c in range(50): if go: for d in range(50): if go: blob_n = TextBlob(sen_list[cnt]) noun_p=blob_n.noun_phrases noun_box=[] for ea in blob_n.parse().split(" "): n=ea.split("/") if n[1] == "NN": noun_box.append(n[0]) json_object[f'{a}{cont_list[b]}{cont_list[c]}{cont_list[d]}']={'sentence':sen_list[cnt],'noun_phrase':noun_p,'nouns':noun_box} for noun in noun_p: if noun in list(noun_list.keys()): noun_list[str(noun)].append(f'{a}{cont_list[b]}{cont_list[c]}{cont_list[d]}') else: noun_list[str(noun)]=[f'{a}{cont_list[b]}{cont_list[c]}{cont_list[d]}'] for nn in noun_box: if nn in list(noun_list.keys()): noun_list[str(nn)].append(f'{a}{cont_list[b]}{cont_list[c]}{cont_list[d]}') else: noun_list[str(nn)]=[f'{a}{cont_list[b]}{cont_list[c]}{cont_list[d]}'] if json_object[f'{a}{cont_list[b]}{cont_list[c]}{cont_list[d]}']=='ZNNN': a="Y" b=0 c=0 d=0 if json_object[f'{a}{cont_list[b]}{cont_list[c]}{cont_list[d]}']=='YNNN': a="X" b=0 c=0 d=0 if cnt == key_cnt-1: print('done') go=False print(list(json_object.keys())[-1]) else: cnt+=1 return json_object,noun_list def find_query(query,sen,nouns): blob_f = TextBlob(query) noun_box={} noun_list=[] sen_box=[] for ea in blob_f.parse().split(" "): n=ea.split("/") if n[1] == "NN": noun_list.append(n[0]) nouns_l=list(nouns.keys()) for nn in nouns_l: for nl in noun_list: if nl in nn: if nl in noun_box: for ea_n in nouns[nn]: noun_box[str(nl)].append(ea_n) else: noun_box[str(nl)]=[] for ea_n in nouns[nn]: noun_box[str(nl)].append(ea_n) for ea in noun_box.values(): for vals in ea: sen_box.append(sen[vals]['sentence']) return noun_box,sen_box with gr.Blocks() as app: inp = gr.Textbox(label="Paste Text",value=text,lines=10) btn = gr.Button("Load Document") with gr.Row(): query=gr.Textbox(label="Search query") search_btn=gr.Button("Search") steps=gr.Number(value=1) out_box=gr.Textbox(label="Results") sen_box=gr.Textbox(label="Sentences") with gr.Row(): with gr.Column(scale=2): sen=gr.JSON(label="Sentences") with gr.Column(scale=1): nouns=gr.JSON(label="Nouns") search_btn.click(find_query,[query,sen,nouns],[out_box,sen_box]) btn.click(get_nouns,[inp,steps],[sen,nouns]) app.launch()