app.py

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()