from googletrans import Translator from googletrans import LANGUAGES import spacy import gradio as gr import nltk from nltk.corpus import wordnet import wikipedia import re import time import random import os import zipfile import ffmpeg from gtts import gTTS #from io import BytesIO from collections import Counter from PIL import Image, ImageDraw, ImageFont import io import numpy as np from docx import Document import textwrap import pandas as pd import pykakasi import hangul_romanize import pinyin from langdetect import detect import datetime import cv2 import math from langchain.document_loaders import YoutubeLoader #need youtube_transcpt_api and pytube installed from youtube_transcript_api import YouTubeTranscriptApi from spacy_syllables import SpacySyllables #https://spacy.io/universe/project/spacy_syllables/ import torch from transformers import AutoTokenizer, AutoModelForSeq2SeqLM, pipeline from flores200_codes import flores_codes #- figure this out after it works import whisper import tempfile import json import shutil from PyPDF2 import PdfReader from gradio_client import Client #When I forgot about the readme file ChatGPT suggested these - Leaving to remember the Readme.md must be updated as well #print(gr.__version__) #import subprocess #subprocess.run(["pip", "install", "--upgrade", "gradio==3.47.1"]) #For huggingface as they sometimes install specific versions on container build #Direct and API based spaces #Make new spaces to to debug inference #https://huggingface.co/spaces/FM-1976/Starling7B-PlayGround - ctransformers #https://huggingface.co/spaces/FM-1976/StableLM-Zepyhr-3B_Playground - llamacpp #https://huggingface.co/spaces/julien-c/zero-gpu-demo/blob/main/app.py - switch the gpu on or off in the interface #Custom gradio components - https://huggingface.co/freddyaboulton #Florida map in gradio component - https://huggingface.co/spaces/freddyaboulton/gradio_folium (folium) #https://huggingface.co/spaces/freddyaboulton/gradio_pdf/blob/main/Dockerfile - PDF component #https://huggingface.co/spaces/jbilcke-hf/faster-image-server/blob/main/app.py - sdxl-turbo api server idea --> test on lambdalabs with share true #Uncomment these for Huggingface nltk.download('maxent_ne_chunker') #Chunker nltk.download('stopwords') #Stop Words List (Mainly Roman Languages) nltk.download('words') #200 000+ Alphabetical order list nltk.download('punkt') #Tokenizer nltk.download('verbnet') #For Description of Verbs nltk.download('omw') nltk.download('omw-1.4') #Multilingual Wordnet nltk.download('wordnet') #For Definitions, Antonyms and Synonyms nltk.download('shakespeare') nltk.download('dolch') #Sight words nltk.download('names') #People Names NER nltk.download('gazetteers') #Location NER nltk.download('opinion_lexicon') #Sentiment words nltk.download('averaged_perceptron_tagger') #Parts of Speech Tagging nltk.download('udhr') # Declaration of Human rights in many languages #spacy.cli.download("en_core_web_sm") #spacy.cli.download('ko_core_news_sm') #spacy.cli.download('ja_core_news_sm') #spacy.cli.download('zh_core_web_sm') #spacy.cli.download("es_core_news_sm") #spacy.cli.download("de_core_news_sm") nlp_en = spacy.load("en_core_web_sm") nlp_de = spacy.load("de_core_news_sm") nlp_es = spacy.load("es_core_news_sm") nlp_ko = spacy.load("ko_core_news_sm") nlp_ja = spacy.load("ja_core_news_sm") nlp_zh = spacy.load("zh_core_web_sm") nlp_en_syllable = spacy.load("en_core_web_sm") nlp_en_syllable.add_pipe("syllables", after="tagger") #https://spacy.io/universe/project/spacy_syllables/ langdropdown_choices = [f"{code}: {name}" for code, name in LANGUAGES.items()] nlp = spacy.load('en_core_web_sm') translator = Translator() def Sentencechunker(sentence): Sentchunks = sentence.split(" ") chunks = [] for i in range(len(Sentchunks)): chunks.append(" ".join(Sentchunks[:i+1])) return " | ".join(chunks) def ReverseSentenceChunker(sentence): reversed_sentence = " ".join(reversed(sentence.split())) chunks = Sentencechunker(reversed_sentence) return chunks def three_words_chunk(sentence): words = sentence.split() chunks = [words[i:i+3] for i in range(len(words)-2)] chunks = [" ".join(chunk) for chunk in chunks] return " | ".join(chunks) def keep_nouns_verbs(sentence): doc = nlp(sentence) nouns_verbs = [] for token in doc: if token.pos_ in ['NOUN','VERB','PUNCT']: nouns_verbs.append(token.text) return " ".join(nouns_verbs) def keep_nouns(sentence): doc = nlp(sentence) nouns = [] for token in doc: if token.pos_ in ['NOUN', 'PUNCT']: nouns.append(token.text) if token.text == '.': nouns.append("\n") return " ".join(nouns) def unique_word_count(text="", state=None): if state is None: state = {} words = text.split() word_counts = state for word in words: if word in word_counts: word_counts[word] += 1 else: word_counts[word] = 1 sorted_word_counts = sorted(word_counts.items(), key=lambda x: x[1], reverse=True) return sorted_word_counts, def Wordchunker(word): chunks = [] for i in range(len(word)): chunks.append(word[:i+1]) return chunks def BatchWordChunk(sentence): words = sentence.split(" ") FinalOutput = "" Currentchunks = "" ChunksasString = "" for word in words: ChunksasString = "" Currentchunks = Wordchunker(word) for chunk in Currentchunks: ChunksasString += chunk + " " FinalOutput += "\n" + ChunksasString return FinalOutput # Translate from English to French langdest = gr.Dropdown(choices=langdropdown_choices, label="Choose Language", value="de: german") #["af", "de", "es", "ko", "ja", "zh-cn"] ChunkModeDrop = gr.Dropdown(choices=["Chunks", "Reverse", "Three Word Chunks", "Spelling Chunks"], label="Choose Chunk Type", value="Chunks") def FrontRevSentChunk (Chunkmode, Translate, Text, langdest): FinalOutput = "" TransFinalOutput = "" if Chunkmode=="Chunks": FinalOutput += Sentencechunker(Text) if Chunkmode=="Reverse": FinalOutput += ReverseSentenceChunker(Text) if Chunkmode=="Three Word Chunks": FinalOutput += three_words_chunk(Text) if Chunkmode=="Spelling Chunks": FinalOutput += BatchWordChunk(Text) if Translate: TransFinalOutput = FinalOutput translated = translator.translate(TransFinalOutput, dest=langdest[:2]) FinalOutput += "\n" + translated.text return FinalOutput # Define a function to filter out non-verb, noun, or adjective words def filter_words(words): # Use NLTK to tag each word with its part of speech tagged_words = nltk.pos_tag(words) # Define a set of parts of speech to keep (verbs, nouns, adjectives) keep_pos = {'VB', 'VBD', 'VBG', 'VBN', 'VBP', 'VBZ', 'NN', 'NNS', 'NNP', 'NNPS', 'JJ', 'JJR', 'JJS'} # Filter the list to only include words with the desired parts of speech filtered_words = [word for word, pos in tagged_words if pos in keep_pos] return filtered_words def SepHypandSynExpansion(text): # Tokenize the text tokens = nltk.word_tokenize(text) NoHits = "" FinalOutput = "" # Find synonyms and hypernyms of each word in the text for token in tokens: synonyms = [] hypernyms = [] for synset in wordnet.synsets(token): synonyms += synset.lemma_names() hypernyms += [hypernym.name() for hypernym in synset.hypernyms()] if not synonyms and not hypernyms: NoHits += f"{token} | " else: FinalOutput += "\n" f"{token}: hypernyms={hypernyms}, synonyms={synonyms} \n" NoHits = set(NoHits.split(" | ")) NoHits = filter_words(NoHits) NoHits = "Words to pay special attention to: \n" + str(NoHits) return NoHits, FinalOutput def WikiSearch(term): termtoks = term.split(" ") for item in termtoks: # Search for the term on Wikipedia and get the first result result = wikipedia.search(item, results=20) return result def create_dictionary(word_list, word_dict = {}): word_list = set(word_list.split(" ")) for word in word_list: key = word[:2] if key not in word_dict: word_dict[key] = [word] else: word_dict[key].append(word) return word_dict def merge_lines(roman_file, w4w_file, full_mean_file, macaronic_file): files = [roman_file, w4w_file, full_mean_file, macaronic_file] merged_lines = [] with open(roman_file.name, "r") as f1, open(w4w_file.name, "r") as f2, \ open(full_mean_file.name, "r") as f3, open(macaronic_file.name, "r") as f4: for lines in zip(f1, f2, f3, f4): merged_line = "\n".join(line.strip() for line in lines) merged_lines.append(merged_line) return "\n".join(merged_lines) TTSLangOptions = gr.Dropdown(choices=langdropdown_choices, value="en: english", label="choose the language of the srt/text accent") #["en", "de", "es", "ja", "ko", "zh-cn"] TTSLangOptions2 = gr.Dropdown(choices=langdropdown_choices, value="en: english", label="choose the language of the srt/text accent") def TTSforListeningPractice(text, language = "en", Repeat10x = False): if Repeat10x: text = text * 10 speech = gTTS(text=text, lang=language[:2], slow="False") speech.save("CurrentTTSFile.mp3") #file = BytesIO() #speech.write_to_fp(file) #file.seek(0) return "CurrentTTSFile.mp3" #file def AutoChorusInvestigator(sentences): sentences = sentences.splitlines() # Use Counter to count the number of occurrences of each sentence sentence_counts = Counter(sentences) # Identify duplicate sentences duplicates = [s for s, count in sentence_counts.items() if count > 1] FinalOutput = "" if len(duplicates) == 0: FinalOutput += "No duplicate sentences found in the file." else: FinalOutput += "The following sentences appear more than once in the file:" for sentence in duplicates: FinalOutput += "\n" + sentence return FinalOutput def AutoChorusPerWordScheduler(sentences): words = set(sentences.split(" ")) wordsoneattime =[] practicestring = "" FinalOutput = "This is supposed to output the words in repetition format (i.e. schedule for repitition) \nCurrent Idea = 1 new word every min and 1 old word every second" + "\n\nWords: \n" for word in words: wordsoneattime.append(word) for i in range(0, 59): practicestring += word + " " practicestring += random.choice(wordsoneattime) + " " FinalOutput += word + "\n " practicestring += "\n" FinalOutput += practicestring return FinalOutput def group_words(inlist): inlisttoks = inlist.split(" ") inlistset = set(inlisttoks) word_groups = [] current_group = [] for word in inlisttoks: current_group.append(word) if len(current_group) == 10: word_groups.append(current_group) current_group = [] if current_group: word_groups.append(current_group) current_group_index = 0 current_group_time = 0 while True: if current_group_time == 60: current_group_index = (current_group_index + 1) % len(word_groups) current_group_time = 0 else: if current_group_time % 10 == 0: random.shuffle(word_groups[current_group_index]) current_group_time += 10 yield " ".join(word_groups[current_group_index]) time.sleep(10) def split_verbs_nouns(text): nlp = spacy.load("en_core_web_sm") doc = nlp(text) verbs_nouns = [] verbs_nouns_str = "" other_words = [] other_words_str = "" pos_string = [] for token in doc: if token.pos_ in ["VERB", "NOUN"]: verbs_nouns_str += token.text + " || " other_words_str += "__ " #verbs_nouns.append(token.text) #elif token.text in [punct.text for punct in doc if punct.is_punct]: # verbs_nouns.append(token.text) # other_words.append(token.text) else: other_words_str += token.text + " || " #other_words.append(token.text) #pos_string.append(token.pos_) verbs_nouns_text = verbs_nouns_str #" ".join(verbs_nouns) other_words_text = other_words_str #" ".join(other_words) pos_string_text = "Debug Test" #" ".join(pos_string) return other_words_text, pos_string_text, verbs_nouns_text SRTLangOptions = gr.Dropdown(choices=["en", "ja", "ko", "zh-cn"], value="en", label="choose the language of the srt") #Left as these four as spacy function def save_string_to_file(string_to_save, file_name, srtdocx): with open(file_name, 'w', encoding='utf-8') as file: file.write(string_to_save) if srtdocx == "True": with open(file_name.split('.')[0] + '.srt', 'w', encoding='utf-8') as file: file.write(string_to_save) srtdocument = Document() srtdocument.add_paragraph(string_to_save) srtdocument.save('SplitSRT.docx') def split_srt_file(text, lang): #file_path): # Open the SRT file and read its contents #with open(file_path, 'r') as f: # srt_contents = f.read() if lang == "en": nlp = spacy.load('en_core_web_sm') if lang == "ja": nlp = spacy.load('ja_core_news_sm') if lang == "ko": nlp = spacy.load('ko_core_news_sm') if lang == "zn-cn": nlp = spacy.load('zn_core_web_sm') srt_contents = text # Split the SRT file by timestamp srt_sections = srt_contents.split('\n\n') srt_sections_POSversion = [] subaswordlist = "" # Loop through each section of the SRT file for i in range(len(srt_sections)): # Split the section into its timestamp and subtitle text section_lines = srt_sections[i].split('\n') timestamp = section_lines[1] subtitle_text = ' | '.join(section_lines[2:]) sub_split_line = nlp(subtitle_text) subtitle_textPOSversion = "" subtitle_text = "" # Replace spaces in the subtitle text with " | " #subtitle_text = subtitle_text.replace(' ', ' | ') for token in sub_split_line: subtitle_text += token.text + " | " subaswordlist += token.text + " " subtitle_textPOSversion += token.pos_ + " | " # Reconstruct the section with the updated subtitle text srt_sections[i] = f"{section_lines[0]}\n{timestamp}\n{subtitle_text[3:]}" srt_sections_POSversion.append(f"{section_lines[0]}\n{timestamp}\n{subtitle_textPOSversion[3:]}\n\n") SplitSRT = '\n\n'.join(srt_sections) SplitPOSsrt = ''.join(srt_sections_POSversion) save_string_to_file(SplitSRT, "SplitSRT.txt", "True") save_string_to_file(SplitPOSsrt, "SplitPOSsrt.txt", "False") subaswordlist = set(subaswordlist.split(" ")) subaswordlistOutput = "" for word in subaswordlist: subaswordlistOutput += "\n | " + word subaswordlistOutput = str(len(subaswordlist)) + "\n" + subaswordlistOutput # Join the SRT sections back together into a single string return subaswordlistOutput, ["SplitSRT.docx", "SplitSRT.txt", "SplitSRT.srt", "SplitPOSsrt.txt"], SplitSRT, SplitPOSsrt def find_string_positions(s, string): positions = [] start = 0 while True: position = s.find(string, start) if position == -1: break positions.append(position) start = position + len(string) return positions def splittext(string): string_no_formaterror = string.replace(" -- > ", " --> ") split_positions = find_string_positions(string_no_formaterror, " --> ") split_strings = [] prepos = 0 for pos in split_positions: pos -= 12 split_strings.append((string[prepos:pos])) #, string[pos:])) prepos = pos FinalOutput = "" stoutput = "" linenumber = 1 #print(linenumber) for item in split_strings[1:]: stoutput = item[0:29] + "\n" + item[30:] stspaces = find_string_positions(stoutput, " ") FinalOutput += str(linenumber) + "\n" + stoutput[:stspaces[-2]] + "\n" FinalOutput += "\n" linenumber += 1 return FinalOutput[2:] def VideotoSegment(video_file, subtitle_file): # Read the subtitle file and extract the timings for each subtitle timings = [] for line in subtitle_file: if '-->' in line: start, end = line.split('-->') start_time = start.strip().replace(',', '.') end_time = end.strip().replace(',', '.') timings.append((start_time, end_time)) # Cut the video into segments based on the subtitle timings video_segments = [] for i, (start_time, end_time) in enumerate(timings): output_file = f'segment_{i}.mp4' ffmpeg.input(video_file, ss=start_time, to=end_time).output(output_file, codec='copy').run() video_segments.append(output_file) # Convert each segment to an MP3 audio file using FFmpeg audio_segments = [] for i in range(len(timings)): output_file = f'segment_{i}.mp3' ffmpeg.input(video_segments[i]).output(output_file, codec='libmp3lame', qscale='4').run() audio_segments.append(output_file) # Create a ZIP archive containing all of the segmented files zip_file = zipfile.ZipFile('segmented_files.zip', 'w') for segment in video_segments + audio_segments: zip_file.write(segment) os.remove(segment) zip_file.close() # Return the ZIP archive for download return 'segmented_files.zip' def text_to_dropdown(text, id=None): #TextCompFormat lines = text.strip().split("\n") html = "{line}\n" html += " \n" return html def text_to_links(text): #TextCompFormat lines = text.strip().split("\n") html = "" for line in lines: if line.startswith("http"): html += f" -- -- | " else: html += line + "Not a link
\n" return html HTMLCompMode = gr.Dropdown(choices=["Dropdown", "Links"], value="Links") def TextCompFormat(text, HTMLCompMode): FinalOutput = "" if HTMLCompMode == "Dropdown": FinalOutput = text_to_dropdown(text) if HTMLCompMode == "Links": FinalOutput = text_to_links(text) return FinalOutput def create_collapsiblebutton(button_id, button_caption, div_content): button_html = f'' div_html = f'
\n{div_content}\n
' return button_html + "\n " + div_html #--------------- def removeTonalMarks(string): tonalMarks = "āēīōūǖáéíóúǘǎěǐǒǔǚàèìòùǜɔɛ" nonTonalMarks = "aeiouuaeiouuaeiouuaeiouoe" noTonalMarksStr = "" for char in string: index = tonalMarks.find(char) if index != -1: noTonalMarksStr += nonTonalMarks[index] else: noTonalMarksStr += char return noTonalMarksStr def calculate_max_chars(image_width, font_size, font_path="ShortBaby.ttf", margin=20): # Create a temporary image to calculate character width img_temp = Image.new('RGB', (100, 100)) draw_temp = ImageDraw.Draw(img_temp) font = ImageFont.truetype(font_path, font_size) # Use a common character for width estimation and multiply by an adjustment factor avg_char_width = draw_temp.textlength("W", font=font) #textsize("W", font=font)[0] max_chars = int(image_width / avg_char_width) * 2 return max_chars def fitimagetexttowidth(text, image_width, font_size, font_path="ShortBaby.ttf"): max_chars = calculate_max_chars(image_width, font_size, font_path) words = text.split() adjusted_text = "" line = "" for word in words: if len(line + word) <= max_chars: line += word + " " else: adjusted_text += line.strip() + "\n" line = word + " " adjusted_text += line.strip() return adjusted_text def add_text_to_image(input_image, text, text_size=36, output_image_path="output.png", border_size=2, font_path="ShortBaby.ttf"): text = removeTonalMarks(text) imagearr = np.asarray(input_image) height, width = imagearr.shape[:2] text = fitimagetexttowidth(text, width, text_size, font_path) img = Image.fromarray(imagearr) draw = ImageDraw.Draw(img) font = ImageFont.truetype(font_path, text_size) # Recalculate position based on the entire block of text text_width, text_height = draw.textbbox((0, 0), text, font=font)[2:] x = (width - text_width) / 2 y = (height - text_height) / 2 # Add text with border for dx, dy in [(0, 0), (border_size, border_size), (-border_size, -border_size), (border_size, -border_size), (-border_size, border_size)]: draw.text((x + dx, y + dy), text, font=font, fill=(255, 255, 255)) draw.text((x, y), text, font=font, fill=(0, 0, 0)) img.save(output_image_path, "PNG") return output_image_path def UnknownTrackTexttoApp(text): #Copy of def OptimisedTtAppForUNWFWO(text): #Buttons and labels autocreation #Change this to spacy version so that data is from one library #Javascript videos on youtube - KodeBase - Change button color Onclick; bro code - button in 5 minutes #GPT3 helped guide the highlighting if statements FinalOutput = "" #sentence = "One Piece chapter 1049 spoilers Thanks to Etenboby from WG forums Chapter 1049: **\"The world we should aspire to\"** * In the cover, someone burned Niji and Yonji\u2019s book * Kaido flashback time. We see his childhood in Vodka Kingdom, and where a few years later he met Whitebeard who told him that Rocks wants to meet him * In the present, part of Raizo\u2019s water leaves the castle and flame clouds disappear. But Momo makes a new one. * Luffy says he will create a world where none of his friends would starve, then he hits Kaido and Kaido falls to the ground of the flower capital. * In another flashback, Kaido tells King that Joy Boy will be the man that can defeat him. **Additional info** *Flashback to Kaidou as a kid* *- His country tries to sell him to the marines but he escapes* *- He rampages in Hachinosu(i think it's blackbeard's island) and Rocks invites him to his crew* *- Young WB appears* *- Rocks flashback suddenly ends* *- Higurashi invites Kaidou* *- The flashback ends with Kaidou telling King he knows who Joy Boy is.* *Back to the present* \\- *Denjirou hugs Hiyori* \\- *Luffy's punch hits Kaidou* *Flashback continues* \\- *King asks: Who is it then?* \\- *Kaidou: The one who will defeat me* \\- *King: Then he will not appear* \\- *Onigashima falls near the capital* \\- *Momo falls* **BREAK NEXT WEEK** https://www.reddit.com/r/OnePiece/comments/umu2h0/one_piece_chapter_1049_spoilers/" #@param {type: "string"} HTMLMainbody = "" GradHTMLMainbody = "" #HTML in gradio components doesnt do css and js properly so nned to highlight doc = nlp(text) iIDNumber = 0 iVerbCount = 0 iNounCount = 0 iWords = 0 allverbs = "" allverbslist = "" allverbids = "" allverbidslist = "" for token in doc: if (token.pos_ == "VERB") or (token.pos_ == "AUX"): HTMLMainbody = HTMLMainbody + " " GradHTMLMainbody = GradHTMLMainbody + " " allverbids = allverbids + str(iVerbCount) + " " iVerbCount += 1 iWords += 1 allverbs = allverbs + token.text + " " elif token.pos_ == "NOUN": HTMLMainbody = HTMLMainbody + " " GradHTMLMainbody = GradHTMLMainbody + " " iNounCount += 1 iWords += 1 elif token.pos_ == "PUNCT": HTMLMainbody = HTMLMainbody + token.text GradHTMLMainbody = GradHTMLMainbody + token.text else: HTMLMainbody = HTMLMainbody + token.text + " " GradHTMLMainbody = GradHTMLMainbody + token.text + " " iWords += 1 iIDNumber += 1 allverbslist = allverbs.split() allverbidslist = allverbids.split() FinalHTML = "" FinalGradHTML = "" FinalCSS = "" FinalJS = "" FinalCSS = FinalCSS + ''' ''' #style='background-color:Gainsboro; There is no general style attribute for buttons but you can make a class and put the style conditions iSents = 0 for sent in doc.sents: iSents += 1 FinalHTML += f"\n \n { FinalCSS } \n\n \n
\n Picture on mouse hover = Visual
Speed = End Goal ==> App Timer Functions ||| \n Sentences: " + str(iSents) + " | Words: " + str(iWords) + " | App elements: " + str(iNounCount + iVerbCount) + " | Verbs: " + str(iVerbCount) + "
" FinalHTML += "\n
" FinalJS = FinalJS + '''\n ''' FinalHTML = FinalHTML + '''

Only Unknown List
\n ''' FinalGradHTML = FinalGradHTML + '''

Only Unknown List
\n ''' FinalOutput = FinalHTML + FinalJS #FinalCSS + FinalJS FinalGradOutput = FinalGradHTML + FinalCSS + FinalJS HTMLDownloadTemp = f'UnknownVerbTrack.html' with open(HTMLDownloadTemp, 'w') as f: f.write(FinalOutput) return HTMLDownloadTemp, FinalGradOutput, FinalOutput #Kathryn Lingel - Pyambic Pentameter Example - PyCon US #Basic Language Model Code def build_model(source_text): list_of_words = source_text.split() model = {} #initialise model to empty dictionary for i, word in enumerate(list_of_words[:-1]): #every word except last word if not word in model: #If word not already in dictionary as a key we add it and initialise to empty array model[word] = [] next_word = list_of_words[i+1] model[word].append(next_word) #model = dictionary per word containing previously seen next words from ANY given text ==> even lyrics translatestring = str(model) translatestring = translatestring.replace("'", "") return model, translatestring def markov_generate(source_text, num_words = 20): model = build_model(source_text) seed = random.choice(list(model.keys())) #Randomly pick a word ==> Heading of the dictionary are keys aka the words output = [seed] #output initialisation using random word for i in range(num_words): last_word = output[-1] #of the output list next_word = random.choice(model[last_word]) # next word to the above word output.append(next_word) #new last word in the output list if next_word not in model: break return ' '.join(output) #New list into a string aka (hopefully) sentence # print(markov_generate("I am the egg man they are the egg men I am the wallrus goo goo g' joob")) def chunk_srt_text(srt_text, chunk_size): # Split the SRT text into chunks of the specified size ChunkList = textwrap.wrap(srt_text, chunk_size) dfFinalOutput = pd.DataFrame(ChunkList, columns = [f"Chunks - { len(ChunkList) }"]) return dfFinalOutput, "" #------------------------------------------------------------------------------------------------------------------------------- #Clean Merge def split_into_fours(text): lines = text.split('\n') chunks = [lines[i:i+4] for i in range(0, len(lines), 4)] return chunks def NumberLineSort(listlen): numbers = list(range(0, listlen)) # create a list of numbers 1 to 12 grouped_numbers = [] for i in range(4): group = [numbers[j] for j in range(i, len(numbers), 4)] grouped_numbers.append(group) return grouped_numbers def SRTLineSort(text): chunks = split_into_fours(text) NumberofBlocks = len(chunks) / 4 printnumber = NumberLineSort(len(chunks)) SRTLinenumber = [] SRTTiming = [] SRTContent = [] FinalOutput = "" for i in range(0, 3): for item in printnumber[i]: if i == 0: SRTLinenumber.append(chunks[item][0]) if i == 1: SRTTiming.append(chunks[item][0]) if i == 2: SRTContent.append(chunks[item]) for i in range(0, int(NumberofBlocks)): FinalOutput += SRTLinenumber[i] + "\n" FinalOutput += SRTTiming[i] + "\n" for i2 in range(0, 4): FinalOutput += SRTContent[i][i2] + "\n" FinalOutput += "\n" return FinalOutput #-------------------------------------------------------------------------------------------------------------------------------- RandomiseTextType = gr.Dropdown(choices=["Words", "Words5x", "Sentences", "Paragraph", "Page"], value="Words") def RandomiseTextbyType(Text, Choice): FinalOutput = "" TempWords = [] if Choice == "Words" : TempWords = Text.split() FinalOutput = reading_randomize_words(TempWords) if Choice == "Words5x" : TempWords = Text.split() FinalOutput = reading_randomize_words5x(TempWords) if Choice == "Sentences" : FinalOutput = reading_randomize_words_in_sentence(Text) if Choice == "Paragraph" : FinalOutput = reading_randomize_words_in_paragraph(Text) if Choice == "Page" : FinalOutput = "Still under Construction" return FinalOutput def reading_randomize_words5x(word): wordScram = "" for item in word: for i in range(5): item = ''.join(random.sample(item, len(item))) wordScram += " " + item #print(item) wordScram += "\n" return wordScram def reading_randomize_words(word): wordScram = "" for item in word: item = ''.join(random.sample(item, len(item))) wordScram += item + " " return wordScram def reading_randomize_words_in_sentence(text): FinalOutput = "" sentences = text.split(".") for sentence in sentences: words = sentence.split() random.shuffle(words) FinalOutput += ' '.join(words) + ". " return FinalOutput def reading_randomize_words_in_paragraph(paragraph): sentences = paragraph.split(".") random.shuffle(sentences) return '. '.join(sentences) def changeexposuretext(text): return f" {text} " #------------------------------------------------------------------------------------------------------------------------------- def ImageTranslationTest(video, subtitle): #Inputs from file Returns a so the path is item.name if subtitle is None: return video.name return [video.name, subtitle.name] #------------------------------------------------------------------------------------------------------------------------------ def AutoSyllablePractice(String): FinalOutput = "" stringlen = len(String) vowels =["a", "e", "i", "o", "y"] VowelSyllables = [] allvowels = "" for i in vowels: if i in String: allvowels = allvowels + " " + String.replace(i, i + " ") allvowels = allvowels + " " + String.replace(i, " " + i) VowelSyllables = allvowels.split(" ") VowelSyllablesstr = "" for item in VowelSyllables: VowelSyllablesstr += item + ", " FinalOutput += VowelSyllablesstr return FinalOutput def GuidedReading(textspreprocess,seperator): FinalOutput = "" if seperator == "Sentences": textspreprocess = textspreprocess.split(".") FinalOutput = "" elif seperator == "lines": textspreprocess = textspreprocess.splitlines() else: textspreprocess = textspreprocess.split(seperator) # Load language-specific models nlp_en = spacy.load("en_core_web_sm") nlp_de = spacy.load("de_core_news_sm") nlp_es = spacy.load("es_core_news_sm") nlp_ko = spacy.load("ko_core_news_sm") nlp_ja = spacy.load("ja_core_news_sm") nlp_zh = spacy.load("zh_core_web_sm") # Create a dictionary of language codes and models nlp_dict = {"en": nlp_en, "de": nlp_de, "es": nlp_es, "ko": nlp_ko, "ja": nlp_ja, "zh-cn": nlp_zh} # Define a function to POS tag and transliterate a text given its language code def pos_tag_and_transliterate(text, lang): # Get the model for the language nlp = nlp_dict.get(lang) if nlp is None: return None # No model found for the language # Process the text and get a list of (token, tag) tuples doc = nlp(text) original_pos_tags = [(token.text, token.pos_) for token in doc] # Use different libraries for different languages if lang == "ja": # Use pykakasi for Japanese from pykakasi import kakasi # Set the modes using properties k = kakasi() k.hira2a = True # Hiragana to ascii k.kata2a = True # Katakana to ascii k.kanji2a = True # Kanji to ascii k.roman = "Hepburn" # Use Hepburn romanization #words = re.findall(r"\S+|\s+", text) words = [token.text for token in doc] # Create a dictionary that maps each original word to its transliterated form with spaces translit_dict = {word: k.convert(word)[0]['hepburn'] for word in words} # Get the transliterated text with spaces transliterated = " ".join(translit_dict.values()) # Replace the words in the original POS tag list with their transliterated forms translit_pos_tags = [(translit_dict.get(word, word), tag) for word, tag in original_pos_tags] # Get the transliterated language code lang_translit = lang + "-translit" elif lang == "ko": # Use hangul-romanize for Korean from hangul_romanize import Transliter from hangul_romanize.rule import academic transliter = Transliter(academic) # Create a dictionary that maps each original word to its transliterated form with spaces words = [token.text for token in doc] translit_dict = {word: " ".join(transliter.translit(word)) for word in words} # Get the transliterated text with spaces transliterated = " ".join(translit_dict.values()) # Replace the words in the original POS tag list with their transliterated forms translit_pos_tags = [(translit_dict.get(word, word), tag) for word, tag in original_pos_tags] # Get the transliterated language code lang_translit = lang + "-translit" elif lang == "zh-cn": # Use pinyin for Chinese from pinyin import get # Get the transliterated text without spaces transliterated = get(text) # Replace the words in the original POS tag list with their transliterated forms translit_pos_tags = [(get(word), tag) for word, tag in original_pos_tags] # Get the transliterated language code lang_translit = lang + "-translit" else: # No transliteration needed for other languages return (text, original_pos_tags, text, original_pos_tags, lang) # Return a tuple of the original text, the original POS tags, the transliterated text, the transliterated POS tags, and the transliterated language code return (text, original_pos_tags, transliterated, translit_pos_tags, lang_translit) # Create an empty list to store the results texts = [] # Loop through each text in the list for text in textspreprocess: # Detect the language of the text lang = detect(text) # Add the text and the language as a tuple to the results list texts.append((text, lang)) # Process each text in the texts list and print the results for text, lang in texts: result = pos_tag_and_transliterate(text, lang) if result is not None: FinalOutput += f"\nLanguage: {lang}" FinalOutput += f"\nText: {result[0]}" if lang in ["ja", "ko", "zh-cn"]: FinalOutput += f"\nTransliterated Text: {result[2]}" FinalOutput += f"\n POS tags: {result[1]}" if lang in ["ja", "ko", "zh-cn"]: FinalOutput += f"\nTPOS tags: {result[3]}" FinalOutput += f"\n" return FinalOutput def create_acronym_map(text): """Create an acronym map from the provided text.""" lines = text.split('\n') acronym_map = {} allacronyms = "" for line in lines: # Remove any special characters and split by whitespace words = line.split() acronym = ''.join([word[0].upper() for word in words if word]) if acronym: # Avoid adding empty lines acronym_map[line] = acronym allacronyms += acronym + " | " return acronym_map, allacronyms def onlyplurals(Inputtext): #NLP or Simple Suffix check doc = nlp(Inputtext) Pluralwords = "" for token in doc: if token.tag_ == "NNS" or token.tag_ == "NNPS": Pluralwords = Pluralwords + token.text + " " TextToks = Pluralwords.split(' ') PluralCounts = Counter(elem for elem in TextToks) return Pluralwords, PluralCounts def LoadNLTKUDHRText(text): NLTKtext = nltk.corpus.udhr.raw(text) CountNLTKText = Counter(NLTKtext.split()).most_common(100) return CountNLTKText, NLTKtext NLTKudhr = gr.Dropdown(choices=['English-Latin1', 'Akuapem_Twi-UTF8', 'Zulu-Latin1', 'Afrikaans-Latin1', 'German_Deutsch-Latin1', 'Japanese_Nihongo-EUC', 'Japanese_Nihongo-SJIS', 'Japanese_Nihongo-UTF8', 'Spanish-Latin1', 'Korean_Hankuko-UTF8', 'Chinese_Mandarin-GB2312', 'Abkhaz-Cyrillic+Abkh', 'Abkhaz-UTF8', 'Achehnese-Latin1', 'Achuar-Shiwiar-Latin1', 'Adja-UTF8', 'Afaan_Oromo_Oromiffa-Latin1', 'Afrikaans-Latin1', 'Aguaruna-Latin1', 'Akuapem_Twi-UTF8', 'Albanian_Shqip-Latin1', 'Amahuaca', 'Amahuaca-Latin1', 'Amarakaeri-Latin1', 'Amuesha-Yanesha-UTF8', 'Arabela-Latin1', 'Arabic_Alarabia-Arabic', 'Asante-UTF8', 'Ashaninca-Latin1', 'Asheninca-Latin1', 'Asturian_Bable-Latin1', 'Aymara-Latin1', 'Balinese-Latin1', 'Bambara-UTF8', 'Baoule-UTF8', 'Basque_Euskara-Latin1', 'Batonu_Bariba-UTF8', 'Belorus_Belaruski-Cyrillic', 'Belorus_Belaruski-UTF8', 'Bemba-Latin1', 'Bengali-UTF8', 'Beti-UTF8', 'Bichelamar-Latin1', 'Bikol_Bicolano-Latin1', 'Bora-Latin1', 'Bosnian_Bosanski-Cyrillic', 'Bosnian_Bosanski-Latin2', 'Bosnian_Bosanski-UTF8', 'Breton-Latin1', 'Bugisnese-Latin1', 'Bulgarian_Balgarski-Cyrillic', 'Bulgarian_Balgarski-UTF8', 'Cakchiquel-Latin1', 'Campa_Pajonalino-Latin1', 'Candoshi-Shapra-Latin1', 'Caquinte-Latin1', 'Cashibo-Cacataibo-Latin1', 'Cashinahua-Latin1', 'Catalan-Latin1', 'Catalan_Catala-Latin1', 'Cebuano-Latin1', 'Chamorro-Latin1', 'Chayahuita-Latin1', 'Chechewa_Nyanja-Latin1', 'Chickasaw-Latin1', 'Chinanteco-Ajitlan-Latin1', 'Chinanteco-UTF8', 'Chinese_Mandarin-GB2312', 'Chuuk_Trukese-Latin1', 'Cokwe-Latin1', 'Corsican-Latin1', 'Croatian_Hrvatski-Latin2', 'Czech-Latin2', 'Czech-UTF8', 'Czech_Cesky-Latin2', 'Czech_Cesky-UTF8', 'Dagaare-UTF8', 'Dagbani-UTF8', 'Dangme-UTF8', 'Danish_Dansk-Latin1', 'Dendi-UTF8', 'Ditammari-UTF8', 'Dutch_Nederlands-Latin1', 'Edo-Latin1', 'English-Latin1', 'Esperanto-UTF8', 'Estonian_Eesti-Latin1', 'Ewe_Eve-UTF8', 'Fante-UTF8', 'Faroese-Latin1', 'Farsi_Persian-UTF8', 'Farsi_Persian-v2-UTF8', 'Fijian-Latin1', 'Filipino_Tagalog-Latin1', 'Finnish_Suomi-Latin1', 'Fon-UTF8', 'French_Francais-Latin1', 'Frisian-Latin1', 'Friulian_Friulano-Latin1', 'Ga-UTF8', 'Gagauz_Gagauzi-UTF8', 'Galician_Galego-Latin1', 'Garifuna_Garifuna-Latin1', 'German_Deutsch-Latin1', 'Gonja-UTF8', 'Greek_Ellinika-Greek', 'Greek_Ellinika-UTF8', 'Greenlandic_Inuktikut-Latin1', 'Guarani-Latin1', 'Guen_Mina-UTF8', 'HaitianCreole_Kreyol-Latin1', 'HaitianCreole_Popular-Latin1', 'Hani-Latin1', 'Hausa_Haoussa-Latin1', 'Hawaiian-UTF8', 'Hebrew_Ivrit-Hebrew', 'Hebrew_Ivrit-UTF8', 'Hiligaynon-Latin1', 'Hindi-UTF8', 'Hindi_web-UTF8', 'Hmong_Miao-Sichuan-Guizhou-Yunnan-Latin1', 'Hmong_Miao-SouthernEast-Guizhou-Latin1', 'Hmong_Miao_Northern-East-Guizhou-Latin1', 'Hrvatski_Croatian-Latin2', 'Huasteco-Latin1', 'Huitoto_Murui-Latin1', 'Hungarian_Magyar-Latin1', 'Hungarian_Magyar-Latin2', 'Hungarian_Magyar-UTF8', 'Ibibio_Efik-Latin1', 'Icelandic_Yslenska-Latin1', 'Ido-Latin1', 'Igbo-UTF8', 'Iloko_Ilocano-Latin1', 'Indonesian-Latin1', 'Interlingua-Latin1', 'Inuktikut_Greenlandic-Latin1', 'IrishGaelic_Gaeilge-Latin1', 'Italian-Latin1', 'Italian_Italiano-Latin1', 'Japanese_Nihongo-EUC', 'Japanese_Nihongo-SJIS', 'Japanese_Nihongo-UTF8', 'Javanese-Latin1', 'Jola-Fogny_Diola-UTF8', 'Kabye-UTF8', 'Kannada-UTF8', 'Kaonde-Latin1', 'Kapampangan-Latin1', 'Kasem-UTF8', 'Kazakh-Cyrillic', 'Kazakh-UTF8', 'Kiche_Quiche-Latin1', 'Kicongo-Latin1', 'Kimbundu_Mbundu-Latin1', 'Kinyamwezi_Nyamwezi-Latin1', 'Kinyarwanda-Latin1', 'Kituba-Latin1', 'Korean_Hankuko-UTF8', 'Kpelewo-UTF8', 'Krio-UTF8', 'Kurdish-UTF8', 'Lamnso_Lam-nso-UTF8', 'Latin_Latina-Latin1', 'Latin_Latina-v2-Latin1', 'Latvian-Latin1', 'Limba-UTF8', 'Lingala-Latin1', 'Lithuanian_Lietuviskai-Baltic', 'Lozi-Latin1', 'Luba-Kasai_Tshiluba-Latin1', 'Luganda_Ganda-Latin1', 'Lunda_Chokwe-lunda-Latin1', 'Luvale-Latin1', 'Luxembourgish_Letzebuergeusch-Latin1', 'Macedonian-UTF8', 'Madurese-Latin1', 'Makonde-Latin1', 'Malagasy-Latin1', 'Malay_BahasaMelayu-Latin1', 'Maltese-UTF8', 'Mam-Latin1', 'Maninka-UTF8', 'Maori-Latin1', 'Mapudungun_Mapuzgun-Latin1', 'Mapudungun_Mapuzgun-UTF8', 'Marshallese-Latin1', 'Matses-Latin1', 'Mayan_Yucateco-Latin1', 'Mazahua_Jnatrjo-UTF8', 'Mazateco-Latin1', 'Mende-UTF8', 'Mikmaq_Micmac-Mikmaq-Latin1', 'Minangkabau-Latin1', 'Miskito_Miskito-Latin1', 'Mixteco-Latin1', 'Mongolian_Khalkha-Cyrillic', 'Mongolian_Khalkha-UTF8', 'Moore_More-UTF8', 'Nahuatl-Latin1', 'Ndebele-Latin1', 'Nepali-UTF8', 'Ngangela_Nyemba-Latin1', 'NigerianPidginEnglish-Latin1', 'Nomatsiguenga-Latin1', 'NorthernSotho_Pedi-Sepedi-Latin1', 'Norwegian-Latin1', 'Norwegian_Norsk-Bokmal-Latin1', 'Norwegian_Norsk-Nynorsk-Latin1', 'Nyanja_Chechewa-Latin1', 'Nyanja_Chinyanja-Latin1', 'Nzema-UTF8', 'OccitanAuvergnat-Latin1', 'OccitanLanguedocien-Latin1', 'Oromiffa_AfaanOromo-Latin1', 'Osetin_Ossetian-UTF8', 'Oshiwambo_Ndonga-Latin1', 'Otomi_Nahnu-Latin1', 'Paez-Latin1', 'Palauan-Latin1', 'Peuhl-UTF8', 'Picard-Latin1', 'Pipil-Latin1', 'Polish-Latin2', 'Polish_Polski-Latin2', 'Ponapean-Latin1', 'Portuguese_Portugues-Latin1', 'Pulaar-UTF8', 'Punjabi_Panjabi-UTF8', 'Purhepecha-UTF8', 'Qechi_Kekchi-Latin1', 'Quechua-Latin1', 'Quichua-Latin1', 'Rarotongan_MaoriCookIslands-Latin1', 'Rhaeto-Romance_Rumantsch-Latin1', 'Romani-Latin1', 'Romani-UTF8', 'Romanian-Latin2', 'Romanian_Romana-Latin2', 'Rukonzo_Konjo-Latin1', 'Rundi_Kirundi-Latin1', 'Runyankore-rukiga_Nkore-kiga-Latin1', 'Russian-Cyrillic', 'Russian-UTF8', 'Russian_Russky-Cyrillic', 'Russian_Russky-UTF8', 'Sami_Lappish-UTF8', 'Sammarinese-Latin1', 'Samoan-Latin1', 'Sango_Sangho-Latin1', 'Sanskrit-UTF8', 'Saraiki-UTF8', 'Sardinian-Latin1', 'ScottishGaelic_GaidhligAlbanach-Latin1', 'Seereer-UTF8', 'Serbian_Srpski-Cyrillic', 'Serbian_Srpski-Latin2', 'Serbian_Srpski-UTF8', 'Sharanahua-Latin1', 'Shipibo-Conibo-Latin1', 'Shona-Latin1', 'Sinhala-UTF8', 'Siswati-Latin1', 'Slovak-Latin2', 'Slovak_Slovencina-Latin2', 'Slovenian_Slovenscina-Latin2', 'SolomonsPidgin_Pijin-Latin1', 'Somali-Latin1', 'Soninke_Soninkanxaane-UTF8', 'Sorbian-Latin2', 'SouthernSotho_Sotho-Sesotho-Sutu-Sesutu-Latin1', 'Spanish-Latin1', 'Spanish_Espanol-Latin1', 'Sukuma-Latin1', 'Sundanese-Latin1', 'Sussu_Soussou-Sosso-Soso-Susu-UTF8', 'Swaheli-Latin1', 'Swahili_Kiswahili-Latin1', 'Swedish_Svenska-Latin1', 'Tahitian-UTF8', 'Tenek_Huasteco-Latin1', 'Tetum-Latin1', 'Themne_Temne-UTF8', 'Tiv-Latin1', 'Toba-UTF8', 'Tojol-abal-Latin1', 'TokPisin-Latin1', 'Tonga-Latin1', 'Tongan_Tonga-Latin1', 'Totonaco-Latin1', 'Trukese_Chuuk-Latin1', 'Turkish_Turkce-Turkish', 'Turkish_Turkce-UTF8', 'Tzeltal-Latin1', 'Tzotzil-Latin1', 'Uighur_Uyghur-Latin1', 'Uighur_Uyghur-UTF8', 'Ukrainian-Cyrillic', 'Ukrainian-UTF8', 'Umbundu-Latin1', 'Urarina-Latin1', 'Uzbek-Latin1', 'Vietnamese-ALRN-UTF8', 'Vietnamese-UTF8', 'Vlach-Latin1', 'Walloon_Wallon-Latin1', 'Wama-UTF8', 'Waray-Latin1', 'Wayuu-Latin1', 'Welsh_Cymraeg-Latin1', 'WesternSotho_Tswana-Setswana-Latin1', 'Wolof-Latin1', 'Xhosa-Latin1', 'Yagua-Latin1', 'Yao-Latin1', 'Yapese-Latin1', 'Yoruba-UTF8', 'Zapoteco-Latin1', 'Zapoteco-SanLucasQuiavini-Latin1', 'Zhuang-Latin1', 'Zulu-Latin1'], label="Choose one the below languages", value='English-Latin1') def SimultaneousSpellingPrac(text): TextToks = text.split() FinalOutput = "For Sentences wrap in another function that calls function per sentences (Spacy) \n" iLongestWord = 0 for tok in TextToks: if len(tok) > iLongestWord: iLongestWord = len(tok) Equaltok = "" for tok in TextToks: Equaltok = Equaltok + tok.ljust(iLongestWord, '0') + " " #https://stackoverflow.com/questions/23216512/python-make-string-equal-length SimulList = [] for i in range(0, iLongestWord): for tok in Equaltok.split(): SimulList.append(tok[i]) iWordSpaces = 0 ZerosFinalOutput = "" for item in SimulList: iWordSpaces += 1 ZerosFinalOutput = ZerosFinalOutput + item if iWordSpaces == len(TextToks): ZerosFinalOutput = ZerosFinalOutput + " " iWordSpaces = 0 FinalOutput = FinalOutput + ZerosFinalOutput + " \n\n" + ZerosFinalOutput.replace("0", "") + " \n\n" + str(iLongestWord) return FinalOutput def FirstLetterSummary(Text): TextToks = Text.split(" ") FinalOutput = '' for tok in TextToks: FinalOutput = FinalOutput + tok[0] + " " WordSuggestLetters = FinalOutput.replace(" ","") WordSuggestToks = [(WordSuggestLetters[i:i+5]) for i in range(0, len(WordSuggestLetters), 5)] WordsSuggest = "" for text in WordSuggestToks: WordsSuggest = WordsSuggest + " " + text return FinalOutput, WordsSuggest #------- def imagebasedreading(inputtext): # Read the user input text file #with open("inputtext.txt", "r", encoding="utf-8") as file: # inputtext = file.read() inputtextlines = inputtext.splitlines() htmlpart1 = """ Image Placeholder with Text Background
""" htmlpart2 = """
""" #If you have a gpu and imagepipeline then src in img tag = filepath of generate image def generate_html(textlines): num_containers = len(textlines) html_string = "" for i in range(num_containers): container = f'''
{textlines[i]} - Placeholder {i + 1}
''' html_string += container return html_string # Generate the HTML based on the number of lines output_html = htmlpart1 + "\n" + generate_html(inputtextlines) + "\n" + htmlpart2 # Save the generated HTML now = datetime.datetime.now() filename = f"ImagePlaceholder{now.strftime('%Y-%m-%d_%H-%M')}_{inputtext[:16]}.html" with open(filename, "w", encoding="utf-8") as file: file.write(output_html) return filename, output_html, output_html def imagebasedreadingwordlevel(inputtext): # Read the user input text file #with open("inputtext.txt", "r", encoding="utf-8") as file: # inputtext = file.read() inputtextlines = inputtext.split(" ") htmlpart1 = """ Image Placeholder with Text Background
""" htmlpart2 = """
""" #If you have a gpu and imagepipeline then src in img tag = filepath of generate image def generate_html(textlines): num_containers = len(textlines) html_string = "" for i in range(num_containers): container = f'''
{textlines[i]} - Placeholder {i + 1}
''' html_string += container return html_string # Generate the HTML based on the number of lines output_html = htmlpart1 + "\n" + generate_html(inputtextlines) + "\n" + htmlpart2 # Save the generated HTML now = datetime.datetime.now() filename = f"ImagePlaceholderwordlevel{now.strftime('%Y-%m-%d_%H-%M')}_{inputtext[:16]}.html" with open(filename, "w", encoding="utf-8") as file: file.write(output_html) return filename, output_html, output_html #-------- guidedreadingseperator = gr.Dropdown(choices=[".", ",", "lines", "Sentences"], value=".", interactive=True) textspreprocess = [ ["Bing created this example \nApple is looking at buying U.K. startup for $1 billion \nApple schaut sich für 1 Milliarde Dollar ein Startup aus Großbritannien an \nApple está mirando comprar una startup del Reino Unido por mil millones de dólares \n애플은 영국의 스타트업을 10억 달러에 사려고 한다 \nアップルは、英国のスタートアップを10億ドルで買収する予定だ \n苹果正考虑以10亿美元收购英国初创公司", "\n"], ["This is an english sentence. This is the second english sentence", "."], ] LLPromptIdeas = """ Lets try this I will give you the english word and you find the <> word and then mix the meaning of the word with the mnemonic Bings Explanation Youre welcome. Im happy to help. If I wanted to explain the rules of this game clearly and concisely, I would do something like this: The game is about finding the <> word for an English word and making a mnemonic that mixes the meaning of the word with the mnemonic. The game has two players: one who gives the English word and one who finds the <> word and makes the mnemonic. The player who gives the English word can choose any word they want, as long as it has a <> equivalent. The player who finds the <> word and makes the mnemonic can use any online or offline resources they want, such as dictionaries, translators, or search engines. The player who finds the <> word and makes the mnemonic should write their answer in the format: The <> word for X is Y <<(pinyin)>>, which means Z. Here are some possible mnemonics that mix the meaning of the word with the mnemonic: A, B, C, D.

Try make sepreate sentences with this acronym as the best wordplay expert in the world - SI(AGM, KPHSIO, ACFJG, DYNAGJ, JBMNNA, HNPDM, BSED, WUENN |
Make jokes while following rules for a syllogism jokes game: The game can be played with any number of people. One person starts by stating a syllogism, which is a logical argument that consists of three parts: a major premise, a minor premise, and a conclusion. The next person must then state a syllogism that has the same conclusion as the first syllogism, but with different major and minor premises. The game continues in this way until someone cannot think of a new syllogism. The person who makes the last valid syllogism wins the game.

Do you know pydot? Please create code for a class diagragm using the pydot library in python for the following topic/entity
(System/First request) Your job is to lengthen Text sent to you in a meaningful way. You must create 20 paragraphs for each Text line sent by the user (User) Text: I went to the beach
replace as many words with emojis in the sentence Life is very sweet
next sentence is AI Town is a virtual town where AI characters live, chat and socialize.

""" LLPromptIdeasasbtns = LLPromptIdeas.split("
") def display_website(link): html = f"" gr.Info("If 404 then the space/page has probably been disabled - normally due to a better alternative") return html def RepititionPracticeTimeCalculator(text, reps_per_item, seconds_per_item): textlines = text.splitlines() lines = len(textlines) FinalOutput = f"Total Time is estimated: { lines * reps_per_item * seconds_per_item / 60 } minutes ( {lines} lines)" return FinalOutput randomExposuremessageText = ["Great Test for LLM function calling (with Gradio Client)", "Unknown Tracker Tab = Incomplete Reading Assistant Idea - HTML app based on text to be read", "Bing mnemonic - lost = dont ignore unusual sounds here inside lost cave", "1000 verbs in lists of 100, verbs = easy setence structure estimation (SVO, SOV, etc.)", "Can put any message here in the navigatoin tab"] def randommarquee(): randomExposuremessagelistitem = "" randomExposuremessagelistitem = str(random.sample(randomExposuremessageText, 1)).replace("['", "").replace("']", "") #randomExposuremessagelistitem2 = str(random.sample(randomExposuremessageText, 1)).replace("['", "").replace("']", "") return f" { randomExposuremessagelistitem } " def TabNavigation(): return gr.Tabs.update(selected=1) #, tabs1=nav1) def segment_video_with_opencv(file_path, segment_duration=60): # Open the video file cap = cv2.VideoCapture(file_path.name) # Get video properties fps = int(cap.get(cv2.CAP_PROP_FPS)) total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) # Calculate total segments required total_segments = math.ceil(total_frames / (fps * segment_duration)) # List to store the file paths of the generated chunks generated_files = [] for segment in range(total_segments): # Define the codec and create VideoWriter object # For .mp4 output, use the H.264 codec with the tag 'mp4v' fourcc = cv2.VideoWriter_fourcc(*'mp4v') output_filename = f'./splitvideo/chunk_{segment}.mp4' out = cv2.VideoWriter(output_filename, fourcc, fps, (int(cap.get(3)), int(cap.get(4)))) for frame_num in range(fps * segment_duration): ret, frame = cap.read() if ret: out.write(frame) else: break out.release() # Append the file path of the generated chunk to the list generated_files.append(output_filename) cap.release() return generated_files def fill_lines(input, num_lines=1000): # Split the input by newline and store it in a list input_list = input.splitlines() # Calculate how many lines each part of the input should get lines_per_part = int(num_lines // len(input_list)) # Initialize an empty list to store the output output_list = [] currentpart = "" # Loop through each part of the input for part in input_list: currentpart += part + "\n" # Fill the list of strings into one string with newlines filled_part = currentpart * lines_per_part #textwrap.fill(wrapped_part, width=lines_per_part) # Append the filled part to the output list output_list.append(filled_part) currentpart = "" # Join the output list into one string with newlines output = "\n".join(output_list) return output def TestSplitandUpdatebtntest(): gr.Info("Incomplete - Text Chosen for Interface") pass def TestSplitandUpdate(Text): return f" Length of the text - { len(Text) }", gr.Button("Incomplete - Set this Text as default for all interfaces") #.click(TestSplitandUpdatebtntest, inputs=None, outputs=None) - Returns the event instead of the button with the event TestSplitandUpdateinput = gr.Textbox(placeholder="Counter and Placeholder one point of entry for the text to be analysed across the whole app") def RepititionInjectedReading(splitby, learning, reading): readingdoc = nlp(reading) learninglist = learning.splitlines() FinalOutput = "" if splitby == "sentences": numofsplitsinreading = sum(1 for _ in readingdoc.sents) #len(readingdoc.sents) is wrong because of generator if splitby == "words": numofsplitsinreading = sum(1 for _ in readingdoc.sents) #len(readingdoc.tokens) is wrong because of generator numofsplitsinlearning = len(learninglist) RepInjectedText = "\n" for i in range(0, numofsplitsinlearning): for sent in readingdoc.sents: RepInjectedText += sent.text + " (" + learninglist[i] + ") " FinalOutput = f"{ numofsplitsinreading } repitition oppurtunities between the sentences: \n { RepInjectedText }" return FinalOutput Repsplitdropdown = gr.Dropdown(choices=["sentences", "words"], value="sentences", label="Split by") def hidingbuttontesttranslate(text): html = """
    """ doc = nlp(text) sentences = [sent.text for sent in doc.sents] for i, sentence in enumerate(sentences): html += f""" """ html += """
    """ return gr.Code(html, language="html"), gr.HTML(html) def extract_video_id(youtube_url): # Regular expression patterns for different YouTube URL formats regex_patterns = [ r"(?<=v=)[a-zA-Z0-9_-]+", # Pattern for 'https://www.youtube.com/watch?v=VIDEO_ID' r"(?<=be/)[a-zA-Z0-9_-]+", # Pattern for 'https://youtu.be/VIDEO_ID' r"(?<=embed/)[a-zA-Z0-9_-]+" # Pattern for 'https://www.youtube.com/embed/VIDEO_ID' ] video_id = None for pattern in regex_patterns: match = re.search(pattern, youtube_url) if match: video_id = match.group(0) break return video_id YTTtranscriptSubtitleOutput = [] YTTtrancriptAnalysedSubtitleOutput = [] def YTTransciptAnalysisandLoad(link): global YTTtranscriptSubtitleOutput, YTTtrancriptAnalysedSubtitleOutput if re.match(r'https?:\/\/youtu\.be\/', link) is not None: print("Needs Reformat") video_id = link.split('/')[3] link = 'https://www.youtube.com/watch?v={}'.format(video_id) else: video_id = extract_video_id(link) #loader = YoutubeLoader.from_youtube_url(f"{ link }", add_video_info=True) #YTTtranscriptloader = loader.load() try: YTTtranscript = YouTubeTranscriptApi.get_transcript(video_id) #YTTtranscript = YTTtranscriptloader[0] YTTtranscriptSubtitleOutput = YTTtranscript except IndexError or AttributeError: print("No Transcript Found") YTTtranscript = "No Transcript found" YTTtrancriptAnalysed = [] YTTTextforTranslation = "" for subtitle in YTTtranscript: YTTtrancriptAnalysed.append({'text': keep_nouns(subtitle['text']), 'start': subtitle['start'], 'duration': subtitle['duration']}) YTTTextforTranslation += "\n" + subtitle["text"] #YTTtrancriptAnalysed = str(len(YTTtranscript.page_content)) + "" + str(YTTtranscript.metadata) YTTtrancriptAnalysedSubtitleOutput = YTTtrancriptAnalysed if re.match(r'https?:\/\/(?:www\.)?youtube\.com\/watch', link) is not None: video_id = re.search(r'v=([^&]+)', link).group(1) link = 'https://www.youtube.com/embed/{}'.format(video_id) return f'', YTTtranscript, YTTtrancriptAnalysed, YTTTextforTranslation def TimedList(list, duration, splits=0): if splits == 0: splits = duration // len(list) for item in list: yield item time.sleep(splits) def synctextboxes(text): return text def subtitle_generator(): global YTTtranscriptSubtitleOutput, YTTtrancriptAnalysedSubtitleOutput """ A generator that yields the subtitle based on the current playback time. :param subtitles: List of subtitles, where each subtitle is a dictionary with 'start', 'duration', and 'text' keys. :param playback_start_time: The time when playback started, used to calculate the current playback time. """ if YTTtranscriptSubtitleOutput == "": return ("No subtitle", "No subtitle", "No subtitle") playback_start_time = time.time() while True: current_time = time.time() - playback_start_time for index, subtitle in enumerate(YTTtranscriptSubtitleOutput): start_time = int(subtitle['start']) end_time = start_time + int(subtitle['duration']) if start_time <= current_time < end_time: yield (YTTtrancriptAnalysedSubtitleOutput[index]['text'], subtitle['text'], subtitle['start']) break else: yield ("", "", "") time.sleep(1) # Wait for 1 second before updating def word_to_k8s_format(word): if len(word) <= 2: return word else: return word[0] + str(len(word) - 2) + word[-1] def ForeignSyllableListenFormat(text): FinalOutput = "" words = nlp_en_syllable(text) FirstSyllablesonly = "" tempsyllablelist = None #Keep only the first syllable of every word for item in words: if item.pos_ != "PUNCT": FinalOutput += item.text + " " tempsyllablelist = item._.syllables if type(tempsyllablelist) == list: FirstSyllablesonly += str(tempsyllablelist[0]) + " " FinalOutput += str(tempsyllablelist) + " " #str(item._.syllables) + " " FinalOutput += str(item._.syllables_count) + " | " else: FinalOutput += item.text + " " FirstSyllablesonly += item.text + " " FinalOutput = "The first Syllables (Listening Practice): \n" + FirstSyllablesonly + "\nSyllable Analysis:\n" + FinalOutput return FinalOutput # For testing purposes # file_paths = segment_video_with_opencv("path_to_your_video.mp4") # print(file_paths) def FirstLetAccronymsSpacy(text): FinalOutput = "" doc = nlp(text) for sent in doc.sents: for word in sent: FinalOutput += word.text[0] FinalOutput += "\n" return FinalOutput def MultiOutputInterface(inputtext): k8sformat = "" inputwordlist = inputtext.split(" ") for word in inputwordlist: k8sformat += word_to_k8s_format(word) + " " FirstLetAccronyms = FirstLetAccronymsSpacy(inputtext) AcronymMap = create_acronym_map(inputtext) Output1 = keep_nouns_verbs(inputtext) Output2 = keep_nouns(inputtext) Plurals = onlyplurals(inputtext) Output3 = TestSplitandUpdate(inputtext) Output4 = ForeignSyllableListenFormat(inputtext) return Output3[1], Output3[0], FirstLetAccronyms, AcronymMap[0], AcronymMap[1], Output1, Output2, Plurals, k8sformat, Output4 def lingualinkassist(text, language): words = text.split(" ") FinalOutput = "Test \n" for word in words: FinalOutput += f"Next lets do '{ word }' in { language }\n" return FinalOutput #Have to define inside blocks w4wsidebysidelangdest = gr.Dropdown(choices=langdropdown_choices, label="Choose Language", value="de: german") #["af", "de", "es", "ko", "ja", "zh-cn", "xh", "zu"] #---------------------------------------------------------------------------------------------------------------------- def w4wsidebysidereadergen(text, langdest): #FrontRevSentChunk as reference FinalOutput = "" Translated = "FWNWO: \n" words = text.split() w4wsidebysidtranslator = Translator() translatedFWO = w4wsidebysidtranslator.translate(text, dest=langdest[:2]) translatedNWO = w4wsidebysidtranslator.translate(words, dest=langdest[:2]) #src or dest #print(translated) #print(dir(translatedNWO[0]), "\n") #FinalOutput += "\n" + translated.text for obj in translatedNWO: # print(f"Original Text: {obj.origin}") # print(f"Translated Text: {obj.text}") # print(f"Source Language: {obj.src}") # print(f"Destination Language: {obj.dest}") # print(f"Pronunciation: {obj.pronunciation}\n") FinalOutput += obj.origin + f" ({obj.text}) " Translated += obj.text + " " speech = gTTS(text=FinalOutput, lang=langdest[:2], slow="False") speech.save("CurrentSidebySideTTSFile.mp3") FinalOutput = "Side by Side Version: " + FinalOutput analysisPrompt = f"{ Translated } \n\nand \n\nFWFWO: \n{ translatedFWO.text } \n\nForeign Words Native Word Order and Foreign Word Order \nIf you had to make the notes on the word by word considerations to transform FWNWO to FWFWO what would that be? (A simple game idea where your response will be the rubrik to mark the players response against)" return FinalOutput, Translated, "FWFWO: \n" + translatedFWO.text, "CurrentSidebySideTTSFile.mp3", analysisPrompt #https://huggingface.co/spaces/Geonmo/nllb-translation-demo/blob/main/app.py def nllbtranscload_models(): # build model and tokenizer #model_name_dict = {'nllb-distilled-600M': 'facebook/nllb-200-distilled-600M', #'nllb-1.3B': 'facebook/nllb-200-1.3B', #'nllb-distilled-1.3B': 'facebook/nllb-200-distilled-1.3B', #'nllb-3.3B': 'facebook/nllb-200-3.3B', # } model_dict = {} #for call_name, real_name in model_name_dict.items(): print('\tLoading model: %s' % 'nllb-distilled-600M' ) #% call_name) model = AutoModelForSeq2SeqLM.from_pretrained('facebook/nllb-200-distilled-600M') #real_name) tokenizer = AutoTokenizer.from_pretrained('facebook/nllb-200-distilled-600M') #real_name) model_dict['nllb-distilled-600M'+'_model'] = model #call_name+'_model'] = model model_dict['nllb-distilled-600M'+'_tokenizer'] = tokenizer #call_name+'_tokenizer'] = tokenizer return model_dict #global model_dict model_dict = nllbtranscload_models() nllb_lang_codes = list(flores_codes.keys()) nllbtranscputotalhistorytext = "Outputs from the above" def nllbtransctranslation(source, target, text): global nllbtranscputotalhistorytext #if len(model_dict) == 2: model_name = 'nllb-distilled-600M' start_time = time.time() source = flores_codes[source] target = flores_codes[target] #source = "eng_Latn" #colab test #target = "aka_Latn" #colab test model = model_dict[model_name + '_model'] tokenizer = model_dict[model_name + '_tokenizer'] translator = pipeline('translation', model=model, tokenizer=tokenizer, src_lang=source, tgt_lang=target) output = translator(text, max_length=400) #Check how much this can be extended end_time = time.time() output = output[0]['translation_text'] result = {'inference_time': end_time - start_time, 'source': source, 'target': target, 'result': output} nllbtranscputotalhistorytext += "\n\n" + result['result'] return result['result'], result['inference_time'], nllbtranscputotalhistorytext def nllbtransctranslationoptionalw4w(source, target, text): global nllbtranscputotalhistorytext FinalOutput = "" FinalInference = 0 nllbtranscputotalhistorytext += "\n\n" textlist = text.split() for item in textlist: currentitem, currentinference, _ = nllbtransctranslation(source, target, item) FinalOutput += item + f" ({ str(currentitem) }) " nllbtranscputotalhistorytext += item + f" ({ str(currentitem) }) " FinalInference += float(currentinference) yield FinalOutput, str(FinalInference), nllbtranscputotalhistorytext #pip install tokenizers==0.13.3 protobuf==3.20.0 - dependency debugging before convert to docker #---------------------------------------------------------------------------------------------------------------------------- physical_similarity = { # Physical transformation similarity 'a': ['e', 'd', 'q', 'o'], 'b': ['d', 'p', 'q', 'h'], 'c': ['e', 'o'], 'd': ['a', 'b', 'p', 'q'], 'e': ['c'], 'g': ['q', 'o'], 'h': ['b', 'n'], 'i': ['l', 'j'], 'j': ['i', 'l'], 'k': ['x'], 'l': ['i', 'j'], 'm': ['n', 'u', 'w'], 'n': ['m', 'u'], 'o': ['a', 'c', 'g', 'q'], 'p': ['b', 'd', 'q'], 'q': ['a', 'b', 'd', 'g', 'o', 'p'], 'r': ['n'], 's': ['z'], 't': ['l'], 'u': ['m', 'n'], 'v': ['w', 'u'], 'w': ['m', 'v'], 'x': ['k'], 'y': ['v'], 'z': ['s'], } phonetic_similarity = { # Phonetic similarity 'c': ['k', 's', 'q'], 'f': ['ph'], 'k': ['c', 'q'], 'q': ['c', 'k'], 's': ['c', 'z'], 'x': ['z'], 'z': ['s', 'x'], # ... other letters } def letterbased_guess_word(target, guess): matching_letters = 0 exact_letters = {} closest_letters = {} physical_similar_letters = {} phonetic_similar_letters = {} # Alphabet dictionary for calculating distance alphabet = {chr(i): i - 97 for i in range(97, 123)} # Count and list exact letter matches in both words for letter in set(target): count = min(target.count(letter), guess.count(letter)) if count > 0: exact_letters[letter] = count for letter in target: # Skip if letter is not a lowercase letter if letter not in alphabet: continue # Check for matching letters if letter in guess: matching_letters += 1 # Find closest letter in guess based on alphabet distance closest_letter = min(guess, key=lambda g: abs(alphabet.get(g, 0) - alphabet[letter])) closest_letters[letter] = closest_letter # Find physical similar letters in guess physical_similar_letters[letter] = [g for g in guess if g in physical_similarity.get(letter, [])] # Find phonetic similar letters in guess phonetic_similar_letters[letter] = [g for g in guess if g in phonetic_similarity.get(letter, [])] return { "matching_letters": matching_letters, "exact_letters": exact_letters, "closest_letters": closest_letters, "physical_similar_letters": physical_similar_letters, "phonetic_similar_letters": phonetic_similar_letters, } #---------------------------------------------------------------------------------------------------------------------------- def whisperlocaltts(filename): model = whisper.load_model("base") audio = whisper.load_audio(filename) audio = whisper.pad_or_trim(audio) mel = whisper.log_mel_spectrogram(audio).to(model.device) options = whisper.DecodingOptions(language= 'en', fp16=False) result = whisper.decode(model, mel, options) if result.no_speech_prob < 0.5: return result.text # Define the Gradio interface inputs and outputs for video split spvvideo_file_input = gr.File(label='Video File') spvsubtitle_file_input = gr.File(label='Subtitle File') spvdownload_output = gr.File(label='Download Segmented Files') Markovlength = gr.Number(value=30, label='Length of generation') groupinput_text = gr.Textbox(lines=2, label="Enter a list of words") groupoutput_text = gr.Textbox(label="Grouped words") Translationchuncksize = gr.Number(value=4998) RepSched_Num_lines = gr.Number(value=1000, label="number of lines") randomExposuremessage = randommarquee() randomExposuremessage2 = randommarquee() VideoTestInput = gr.File(label="select a mp4 video file", file_types=[".mp4"]) VideoTestSubtitleInput = gr.File(label="select a subtitle file", file_types=[".txt", ".srt", ".vtt"]) VideoSplitTestInput = gr.File(label="select a mp4 video file", file_types=[".mp4"]) SplitVideoOutput = gr.FileExplorer(root_dir='./splitvideo') #--------------------------------------------------------------------------------------------------------- def build_sentence_basic(subject, verb, obj, order): if order == "SVO": return f"{subject} {verb} {obj}." elif order == "SOV": return f"{subject} {obj} {verb}." else: # VSO return f"{verb} {subject} {obj}." def build_sentence(subject, verb, obj, adjective, adverb, prep_phrase, conjunction, structure): structures = { "SVOAAPC": f"{subject} {verb} {obj} {adjective} {adverb} {prep_phrase} {conjunction}.", "SVOAPC": f"{subject} {verb} {obj} {adjective} {prep_phrase} {conjunction}.", "SVOAC": f"{subject} {verb} {obj} {adjective} {conjunction}.", "SVOAPAC": f"{subject} {verb} {obj} {adverb} {prep_phrase} {adjective} {conjunction}.", "SVCAOAP": f"{subject} {verb} {conjunction} {adverb} {obj} {adjective} {prep_phrase}.", "SVACOAP": f"{subject} {verb} {adverb} {conjunction} {obj} {adjective} {prep_phrase}.", "SVACOP": f"{subject} {verb} {adverb} {conjunction} {obj} {prep_phrase}.", "SVCAPO": f"{subject} {verb} {conjunction} {adjective} {prep_phrase} {obj}.", "SVAPO": f"{subject} {verb} {adverb} {prep_phrase} {obj}.", "SVCPO": f"{subject} {verb} {conjunction} {prep_phrase} {obj}.", "SVOAA": f"{subject} {verb} {obj} {adjective} {adverb}.", "SVAPA": f"{subject} {verb} {adverb} {prep_phrase} {adjective}.", "SVPAO": f"{subject} {verb} {prep_phrase} {adjective} {obj}.", "SVOAP": f"{subject} {verb} {obj} {adverb} {prep_phrase}.", "SVPOA": f"{subject} {verb} {prep_phrase} {obj} {adjective}.", "SVOPA": f"{subject} {verb} {obj} {prep_phrase} {adjective}.", "SADVV": f"{subject} {adverb} {verb}.", "SADJV": f"{subject} {adjective} {verb}.", "SPPV": f"{subject} {prep_phrase} {verb}.", "SCONJV": f"{subject} {conjunction} {verb}.", "SADVPPV": f"{subject} {adverb} {prep_phrase} {verb}.", "SADJCONJV": f"{subject} {adjective} {conjunction} {verb}.", "ASVOP": f"{adverb}, {subject} {verb} {obj} {prep_phrase}.", "PSVOAC": f"{prep_phrase}, {subject} {verb} {obj} {adjective} {conjunction}.", "CSVO": f"{conjunction} {subject} {verb} {obj}.", "SVOPC": f"{subject} {verb} {obj} {prep_phrase} {conjunction}.", "SVCOP": f"{subject} {verb} {conjunction} {obj} {prep_phrase}.", "SVOCA": f"{subject} {verb} {obj} {conjunction} {adverb}." } return structures.get(structure, "Invalid structure.").capitalize() sentbuildchoices = [ "SVOAAPC", "SVOAPC", "SVOAC", "SVOAPAC", "SVCAOAP", "SVACOAP", "SVACOP", "SVCAPO", "SVAPO", "SVCPO", "SVOAA", "SVAPA", "SVPAO", "SVOAP", "SVPOA", "SVOPA", "SADVV", "SADJV", "SPPV", "SCONJV", "SADVPPV", "SADJCONJV", "ASVOP", "PSVOAC", "CSVO", "SVOPC", "SVCOP", "SVOCA" ] sentbuildsubjects = ["The curious cat", "The playful dog", "The majestic eagle", "The wise owl", "The friendly dolphin", "The cat", "The dog", "The bird", "The elephant", "The lion", "The monkey", "The rabbit", "The turtle"] sentbuildverbs = ["chases", "discovers", "explores", "investigates", "observes", "chases", "eats", "watches", "plays with", "jumps over", "runs from", "hides from", "sleeps on"] sentbuildobjects = ["the colorful butterfly", "the mysterious cave", "the ancient ruins", "the hidden treasure", "the underwater world"] sentbuildadjectives = ["beautiful", "enchanting", "fascinating", "intriguing", "marvelous", "the mouse", "the bone", "the worm", "the ball", "the fence", "the hunter", "the predator", "the leaf"] sentbuildadverbs = ["cautiously", "eagerly", "enthusiastically", "patiently", "swiftly"] sentbuildprep_phrases = ["in the dense forest", "near the babbling brook", "on the sandy beach", "under the starry sky", "within the deep ocean"] sentbuildconjunctions = ["and", "but", "yet", "for", "so"] def sentbuildgenerate_quiz_question(): structure = random.choice(sentbuildchoices) subject = random.choice(sentbuildsubjects) verb = random.choice(sentbuildverbs) obj = random.choice(sentbuildobjects) adjective = random.choice(sentbuildadjectives) adverb = random.choice(sentbuildadverbs) prep_phrase = random.choice(sentbuildprep_phrases) conjunction = random.choice(sentbuildconjunctions) sentence = build_sentence(subject, verb, obj, adjective, adverb, prep_phrase, conjunction, structure) return sentence, "Identify the sentence structure:", gr.Radio(sentbuildchoices, label="Options"), structure def sentbuildcheck_answer(selected, correct): if selected == correct: return "Correct!", gr.update(interactive=False) else: return "Incorrect. Please try again.", gr.update(interactive=True) #------------------------------------------------------------------------------------------------ def display_subtitles_from_zip(zip_file_path): temp_dir = tempfile.mkdtemp() try: with zipfile.ZipFile(zip_file_path.name, "r") as zip_file: zip_file.extractall(temp_dir) # Extract all files to the temporary directory with open(f"{temp_dir}/preprocessed_subtitles.json", "r") as file: preprocessed_subtitles = json.load(file) preprocessed_subtitles.sort(key=lambda x: x['start']) yield "Subtitles loaded. Playback will begin shortly...", [] time.sleep(2) current_time = 0 for subtitle in preprocessed_subtitles: wait_time = subtitle['start'] - current_time if wait_time > 0: time.sleep(wait_time) current_time += wait_time subtitle_output = f"Start Time: {subtitle['start']} s\n" subtitle_output += f"Duration: {subtitle['duration']} s\n" subtitle_output += f"Text: {subtitle['text']}\n" subtitle_output += f"Analysed Text: {subtitle['analysed_text']}\n" subtitle_output += "Images:\n" images = [] for image_name in subtitle['image_paths']: image_path = f"{temp_dir}/{image_name}" if Image.open(image_path): # Just a simple check if the file is an image images.append(image_path) subtitle_output += "Word Durations:\n" for duration in subtitle['word_durations']: subtitle_output += f"{duration} ms\n" subtitle_output += "---\n" yield subtitle_output, images time.sleep(subtitle['duration']) current_time += subtitle['duration'] finally: shutil.rmtree(temp_dir) # Clean up the temporary directory #------------------------------------------------------------------------------------------------------------------------- nllbtrans_original_order = None # Function to check the user's guesses def nllbtrans_check_order(*inputs): global nllbtrans_original_order # Fill unselected dropdowns with 0 guesses = [int(inp) if inp else 0 for inp in inputs] if guesses == nllbtrans_original_order: return "Correct Order!" else: return "Incorrect Order! Try Again. Ensure all dropdowns are selected." # ---------------------------------------------------------------------------------------------------- def audioformatbrainstorm(chunkmode, translate, text, langdestchoice, choice): FrontRevSentChunkbrainstormoutput = FrontRevSentChunk(chunkmode, translate, text, langdestchoice) AutoSyllablePracticebrainstormoutput = AutoSyllablePractice(text) RandomiseTextbyTypebrainstormoutput = RandomiseTextbyType(text, choice) create_dictionarybrainstormoutput = create_dictionary(text) keep_nouns_verbsbrainstormoutput = keep_nouns_verbs(text) split_verbs_nounsbrainstormoutput = split_verbs_nouns(text) SimultaneousSpellingPracbrainstormoutput = SimultaneousSpellingPrac(text) FirstLetterSummarybrainstormoutput = FirstLetterSummary(text) AutoChorusPerWordSchedulerbrainstormoutput = AutoChorusPerWordScheduler(text) return FrontRevSentChunkbrainstormoutput, AutoSyllablePracticebrainstormoutput, RandomiseTextbyTypebrainstormoutput, create_dictionarybrainstormoutput, keep_nouns_verbsbrainstormoutput, split_verbs_nounsbrainstormoutput[0], split_verbs_nounsbrainstormoutput[1], split_verbs_nounsbrainstormoutput[2], SimultaneousSpellingPracbrainstormoutput, FirstLetterSummarybrainstormoutput, AutoChorusPerWordSchedulerbrainstormoutput # ---------------------------------------------------------------------------------------------------- def autoprocessrender_extract_text_from_pdf(pdf_file): reader = PdfReader(pdf_file) text = "" for page in reader.pages: text += page.extract_text() return text def autoprocessrender_read_text_file(text_file): return text_file.read().decode('utf-8') def autoprocessrender_split_text_into_chunks(text, chunk_size=2000): return [text[i:i+chunk_size] for i in range(0, len(text), chunk_size)] def autoprocessrender_find_words_ending_in_s(text): words = text.split() return [word for word in words if word.endswith('s')] def autoprocessrender_handle_pdf(pdf_file): text = autoprocessrender_extract_text_from_pdf(pdf_file) return autoprocessrender_split_text_into_chunks(text) def autoprocessrender_handle_text_file(text_file): text = autoprocessrender_read_text_file(text_file) return autoprocessrender_split_text_into_chunks(text) def autoprocessrender_generate_ai_notes(chunk): FinalOutput = "Analysed Text placeholder for - " + chunk return FinalOutput def autoprocessrender_save_all_text(chunks, notes, ai_notes): all_text = "" for i, chunk in enumerate(chunks): all_text += f"Chunk {i+1}:\n{chunk}\nNotes:\n{notes[i]}\nAI Notes:\n{ai_notes[i]}\n\n" return all_text def partial_NWOtranslate_closed_class_words(text, sidebyside=True): # Updated dictionaries prepositions = { 'of': 'von', 'in': 'in', 'on': 'auf', 'at': 'bei', 'by': 'durch', 'with': 'mit', 'from': 'aus', 'to': 'zu', 'under': 'unter', 'above': 'über', 'up': 'hinauf', 'down': 'hinunter', 'over': 'über', 'across': 'über', 'through': 'durch', 'against': 'gegen', 'among': 'unter', 'within': 'innerhalb', 'without': 'ohne', 'before': 'vor', 'after': 'nach', 'between': 'zwischen', 'during': 'während', 'towards': 'zu', 'except': 'außer', 'like': 'wie' } conjunctions = { 'and': 'und', 'but': 'aber', 'or': 'oder', 'nor': 'noch', 'for': 'für', 'so': 'also', 'yet': 'doch', 'after': 'nachdem', 'although': 'obwohl', 'though': 'obgleich', 'because': 'weil', 'if': 'wenn', 'unless': 'es sei denn', 'since': 'seit', 'while': 'während', 'until': 'bis', 'as': 'wie', 'when': 'wenn', 'where': 'wo', 'whether': 'ob' } articles = { 'the': 'der', 'a': 'ein', 'an': 'ein' } auxiliary_verbs = { 'will': 'werden', 'would': 'würde', 'shall': 'soll', 'should': 'sollte', 'can': 'kann', 'could': 'könnte', 'may': 'darf', 'might': 'möchte', 'must': 'muss', 'do': 'tun', 'am': 'bin', 'is': 'ist', 'are': 'sind', 'was': 'war', 'were': 'waren', 'being': 'seiend', 'been': 'gewesen', 'has': 'hat', 'have': 'haben', 'had': 'hatte', 'does': 'tut', 'did': 'tat' } pronouns = { 'I': 'ich', 'you': 'du', 'he': 'er', 'him': 'ihn', 'his': 'sein', 'she': 'sie', 'her': 'ihr', 'it': 'es', 'we': 'wir', 'us': 'uns', 'they': 'sie', 'them': 'sie', 'me': 'mich', 'my': 'mein', 'myself': 'mich selbst', 'your': 'dein', 'yours': 'dein', 'himself': 'sich selbst', 'herself': 'sich selbst', 'itself': 'sich selbst', 'ourselves': 'uns selbst', 'yourselves': 'euch selbst', 'themselves': 'sich selbst', 'its': 'sein', 'ours': 'unsere', 'theirs': 'ihre', 'which': 'welche', 'who': 'wer', 'whom': 'wen', 'whose': 'wessen', 'that': 'das', 'these': 'diese', 'those': 'jene', 'this': 'dies', 'what': 'was', 'any': 'irgendein', 'all': 'alle', 'some': 'einige', 'none': 'keiner' } adverbs = { 'very': 'sehr', 'well': 'gut', 'fast': 'schnell', 'hard': 'hart', 'loud': 'laut', 'far': 'weit', 'long': 'lang', 'high': 'hoch', 'deep': 'tief', 'old': 'alt', 'new': 'neu', 'just': 'gerade', 'almost': 'fast', 'already': 'schon', 'even': 'sogar', 'still': 'noch', 'yet': 'noch', 'too': 'zu', 'much': 'viel', 'so': 'so', 'enough': 'genug', 'extremely': 'äußerst', 'incredibly': 'unglaublich', 'really': 'wirklich', 'highly': 'hoch', 'fairly': 'ziemlich', 'quite': 'ziemlich', 'nearly': 'fast', 'utterly': 'völlig', 'here': 'hier', 'there': 'dort', 'where': 'wo', 'when': 'wann', 'why': 'warum', 'how': 'wie', 'now': 'jetzt', 'then': 'dann', 'always': 'immer', 'never': 'nie', 'often': 'oft', 'sometimes': 'manchmal', 'seldom': 'selten', 'once': 'einmal' } # Create a dictionary to store all translations translations = {} translations.update(prepositions) translations.update(conjunctions) translations.update(articles) translations.update(auxiliary_verbs) translations.update(pronouns) translations.update(adverbs) # Replace English closed-class words with German equivalents using regex def translate_match(match): word = match.group(0) translation = translations.get(word, word) if sidebyside and translation != word: return f"{word} ({translation})" return translation pattern = re.compile(r'\b(' + '|'.join(re.escape(key) for key in translations.keys()) + r')\b') translated_text = pattern.sub(translate_match, text) return translated_text #------------------------------------------------------------------------------------------------------- def TestGradioClientQwen270b(text): client = Client("Qwen/Qwen2-72B-Instruct") result = client.predict( query=text, #"Hello!!", history=[], system="You are a helpful assistant.", api_name="/model_chat" ) print(result[1][0]) print(result[2]) return result #---------------------------------------------------------------------------------------------------------------------- def clearfocusreadertext(): return "", "", "", "" def singlefocusreadertext(text): return f" {text} ", "", "", "" def multifocusreadertext(text): textlength = len(text) text2 = text[int(textlength * 0.25):] + text[:int(textlength * 0.25)] text3 = text[int(textlength * 0.5):] + text[:int(textlength * 0.5)] text4 = text[int(textlength * 0.75):] + text[:int(textlength * 0.75)] return f" {text} ", f" {text2} ", f" {text3} ", f" {text4} " #---------------------------------------------------------------------------------------------------------------------- def nllb_chunk_text(text): # Rough conversion: 1 token ≈ 4 characters chars_per_token = 4 chunk_size = 150 * chars_per_token # Split the text into chunks of approximately 300 tokens chunks = textwrap.wrap(text, width=chunk_size) # Join the chunks with newline characters chunked_text = "\n\n".join(chunks) chunked_text = f"Current Size = {chunk_size} characters \n(Triple click to select a paragraph) \n\n" + chunked_text return chunked_text #-------------------------------------------------------------------------------------------------------------------------------------------- with gr.Blocks() as lliface: #theme=gr.themes.Glass(primary_hue='green', secondary_hue='red', neutral_hue='blue', ) gr.HTML('
    Reading comprehension speed through picture based compression (collage), Live Image Subtitles and Listening Comprehension Test - -- Lingua Link (Simple GPT for assistinng image creation) -- |
    ---- Under Construction: Very Slowly figuring out what AI intergrated interface means (Chat vs Forms vs Function calling vs Sensor + Trigger vs Agent) | How to end copy paste once and for all? ----
    All the apis from the below space need to be treated like RAG as notes for the LLM to read before providing its answer
    ') with gr.Accordion("Some Useful Spaces (My Bookmarks)", open=False): with gr.Accordion("Translation or STT HF Spaces/Sites (Click Here to Open) - Use to get rough translations", open=False): with gr.Row(): linktotranslate = gr.Dropdown(choices=["https://rasmus-whisper-youtube-crosslingual-subtitles.hf.space", "https://hf-audio-whisper-large-v3.hf.space", "https://pyf98-owsm-v3-demo.hf.space", "https://kadirnar-multilingual-translation.hf.space", "https://geonmo-nllb-translation-demo.hf.space", "https://facebook-seamless-m4t-v2-large.hf.space", "https://sanchit-gandhi-whisper-jax-diarization.hf.space", "https://sanchit-gandhi-whisper-jax.hf.space", "https://sanchit-gandhi-whisper-large-v2.hf.space", "https://facebook-seamless-m4t.hf.space"], label="Choose/Cancel type any .hf.space link here (can also type a link)'", allow_custom_value=True) translatespacebtn = gr.Button("Use the chosen URL to load interface with a translate model") translatespace = gr.HTML("Translate Space Chosen will load here") translatespacebtn.click(display_website, inputs=linktotranslate, outputs=translatespace) with gr.Accordion("Audio Gen HF Spaces/Sites (Click Here to Open)", open=False): with gr.Row(): linktoaudiogen = gr.Dropdown(choices=["https://facebook-seamless-m4t-v2-large.hf.space", "https://mms-meta-mms.hf.space", "https://coqui-xtts.hf.space", "https://suno-bark.hf.space", "https://mrfakename-metavoice-1b-v0-1.hf.space"], label="Choose/Cancel type any .hf.space link here (can also type a link)'", allow_custom_value=True) audiogenspacebtn = gr.Button("Use the chosen URL to load interface with a chat model") audiogenspace = gr.HTML("Chat Space Chosen will load here") audiogenspacebtn.click(display_website, inputs=linktoaudiogen, outputs=audiogenspace) with gr.Accordion("Image Gen or Animation HF Spaces/Sites (Click Here to Open) - Use with the image placeholder in Workflows tab", open=False): with gr.Row(): linktoimagegen = gr.Dropdown(choices=["https://prodia-sdxl-stable-diffusion-xl.hf.space", "https://prodia-fast-stable-diffusion.hf.space", "https://lllyasviel-ic-light.hf.space", "https://gparmar-img2img-turbo-sketch.hf.space", "https://artificialguybr-artificialguybr-demo-lora.hf.space", "https://kadirnar-open-sora.hf.space", "https://bytedance-animatediff-lightning.hf.space", "https://bytedance-hyper-sdxl-1step-t2i.hf.space", "https://ehristoforu-dalle-3-xl-lora-v2.hf.space", "https://multimodalart-cosxl.hf.space", "https://radames-real-time-text-to-image-sdxl-lightning.hf.space", "https://cagliostrolab-animagine-xl-3-1.hf.space", "https://wangfuyun-animatelcm-svd.hf.space" "https://modelscope-transferanything.hf.space", "https://visionmaze-magic-me.hf.space", "https://wangfuyun-animatelcm.hf.space", "https://artgan-diffusion-api.hf.space", "https://multimodalart-stable-cascade.hf.space", "https://ap123-sdxl-lightning.hf.space", "https://google-sdxl.hf.space", "https://guoyww-animatediff.hf.space", "https://segmind-segmind-stable-diffusion.hf.space", "https://simianluo-latent-consistency-model.hf.space", "https://artificialguybr-studio-ghibli-lora-sdxl.hf.space", "https://artificialguybr-pixel-art-generator.hf.space", "https://fffiloni-sdxl-control-loras.hf.space"], label="Choose/Cancel type any .hf.space link here (can also type a link)'", allow_custom_value=True) imagegenspacebtn = gr.Button("Use the chosen URL to load interface with a chat model") imagegenspace = gr.HTML("Chat Space Chosen will load here") imagegenspacebtn.click(display_website, inputs=linktoimagegen, outputs=imagegenspace) with gr.Accordion("3D Model Spaces/Sites (Click Here to Open) - Image to Blender?", open=False): with gr.Row(): linktoThreedModel = gr.Dropdown(choices=["https://tencentarc-instantmesh.hf.space", "https://ashawkey-lgm.hf.space", "https://dylanebert-lgm-mini.hf.space", "https://dylanebert-splat-to-mesh.hf.space", "https://dylanebert-multi-view-diffusion.hf.space"], label="Choose/Cancel type any .hf.space link here (can also type a link)'", allow_custom_value=True) ThreedModelspacebtn = gr.Button("Use the chosen URL to load interface with a translate model") ThreedModelspace = gr.HTML("Translate Space Chosen will load here") ThreedModelspacebtn.click(display_website, inputs=linktoThreedModel, outputs=ThreedModelspace) with gr.Accordion("Image Understanding/Vision Conversation HF Spaces/Sites (Click Here to Open)", open=False): with gr.Row(): linktovisionund = gr.Dropdown(choices=["https://google-paligemma-hf.hf.space", "https://kingnish-gpt-4o.hf.space", "https://linfanluntan-grounded-sam.hf.space", "https://merve-llava-next.hf.space", "https://badayvedat-llava.hf.space", "https://otter-ai-otterhd-demo.hf.space", "https://adept-fuyu-8b-demo.hf.space", "https://xinyu1205-recognize-anything.hf.space", "https://languagebind-moe-llava.hf.space", "https://vision-cair-minigpt4.hf.space", "https://fffiloni-live-vision.hf.space", "https://ysharma-gemini-pro-vision-chat.hf.space", "https://kvikontent-chatgpt-vision.hf.space"], label="Choose/Cancel type any .hf.space link here (can also type a link)'", allow_custom_value=True) visionundspacebtn = gr.Button("Use the chosen URL to load interface with a chat model") visionundspace = gr.HTML("Chat Space Chosen will load here") visionundspacebtn.click(display_website, inputs=linktovisionund, outputs=visionundspace) with gr.Accordion("LLM HF Spaces/Sites (Click Here to Open) - Use 'Acronym Map Creation Space' Tab with this - Ask for Translation of image tags made below, sentence to emojis, Wordlists, Test Conversations, Get Grammar Explanations etc., Can use GPT-4 or new SOTA to review the conversation", open=False): with gr.Row(): linktochat = gr.Dropdown(choices=["https://labs.perplexity.ai/", "https://chat.lmsys.org", "https://sdk.vercel.ai/docs", "https://qwen-qwen-max-0428.hf.space", "https://cohereforai-c4ai-command-r-plus.hf.space", "https://huggingface.co/spaces/eswardivi/Phi-3-mini-128k-instruct", "https://eswardivi-phi-3-mini-4k-instruct.hf.space", "https://cyzgab-catch-me-if-you-can.hf.space", "https://snowflake-snowflake-arctic-st-demo.hf.space", "https://qwen-qwen1-5-110b-chat-demo.hf.space", "https://ysharma-chat-with-meta-llama3-8b.hf.space", "https://databricks-dbrx-instruct.hf.space", "https://qwen-qwen1-5-moe-a2-7b-chat-demo.hf.space", "https://cohereforai-c4ai-command-r-v01.hf.space", "https://ehristoforu-mixtral-46-7b-chat.hf.space", "https://stabilityai-stablelm-2-1-6b-zephyr.hf.space", "https://qwen-qwen1-5-72b-chat.hf.space", "https://deepseek-ai-deepseek-coder-7b-instruct.hf.space", "https://01-ai-yi-34b-chat.hf.space", "https://ysharma-zephyr-playground.hf.space", "https://huggingfaceh4-zephyr-chat.hf.space", "https://osanseviero-mistral-super-fast.hf.space", "https://artificialguybr-qwen-14b-chat-demo.hf.space", "https://huggingface-projects-llama-2-7b-chat.hf.space", "https://ysharma-explore-llamav2-with-tgi.hf.space", "https://mosaicml-mpt-30b-chat.hf.space", "https://huggingfaceh4-falcon-chat.hf.space", "https://uwnlp-guanaco-playground-tgi.hf.space", "https://stabilityai-stablelm-tuned-alpha-chat.hf.space", "https://mosaicml-mpt-7b-storywriter.hf.space", "https://huggingfaceh4-starchat-playground.hf.space", "https://bigcode-bigcode-playground.hf.space", "https://mosaicml-mpt-7b-chat.hf.space", "https://huggingchat-chat-ui.hf.space", "https://togethercomputer-openchatkit.hf.space"], label="Choose/Cancel type any .hf.space link here (can also type a link)'", allow_custom_value=True) chatspacebtn = gr.Button("Use the chosen URL to load interface with a chat model. For sdk.vercel click the chat button on the top left. For lymsys / chat arena copy the link and use a new tab") with gr.Accordion("Some prompt ideas", open=False): with gr.Accordion("Prompts in text (Manual copy paste)", open=False): gr.HTML(LLPromptIdeas) with gr.Group(): promptidea0 = gr.Code(label="Prompt Idea 1", value=LLPromptIdeasasbtns[0]) promptidea1 = gr.Code(label="Prompt Idea 2", value=LLPromptIdeasasbtns[1]) promptidea2 = gr.Code(label="Prompt Idea 3", value=LLPromptIdeasasbtns[2]) promptidea3 = gr.Code(label="Prompt Idea 4", value=LLPromptIdeasasbtns[3]) promptidea4 = gr.Code(label="Prompt Idea 5", value=LLPromptIdeasasbtns[4]) chatspace = gr.HTML("Chat Space Chosen will load here") chatspacebtn.click(display_website, inputs=linktochat, outputs=chatspace) #----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- with gr.Row(): with gr.Column(scale=1): gr.HTML("""
    Some useful links
    -- Gradio Playground - Debug UI Fast -- | -- Opensource List -- | -- Open LLM Leaderboard -- | -- Openxlabs - Huggingface Alternative -- | -- Whisper JAX -- | -- Google Translate -- | -- Modelscope Text to Video -- | -- stable-diffusion 2 -- | -- stable-diffusion 1 -- | -- karlo 1 -- | -- Bark (TTS) -- | -- Offline Text Model Demos -- | -- SAM with Clip -- | -- Eleven Labs -- | -- Animate an Image -- | -- Clone a voice -- | -- OpenAI pricing -- | -- Image Training Data Search -- | -- Huggingface Chat -- | -- 128x128 Stable Diffusion (Fast) -- | -- Search 95 million research abstracts -- | -- Tiny Stories Dataset -- | -- Visualglm6b - Discuss images -- | -- RAM and Tag2Text -- | -- Potat1 Text2vid -- | -- Alexandria Prohect (Will Deque) - Free Embeddings -- | -- Google Arts and Culture Portal -- | -- Word Level Timestamps -- | -- NLLB 600M Demo -- = -- NLLB Github -- | -- Zeroscope v2 Text to video -- | -- ComfyUI Text to Image -- | -- Deepfloyd IF - Text in image -- | -- ChatGPT Custom Plugins Test Space -- | -- r/LocalLlama -- | -- r/Singularity -- | -- SD-XL Test Space -- | -- Seamless M4T - Translation one stop shop -- | -- Code Llama playground -- | -- Text to sing -- | -- Stable Diffusion Webui (Camenduru Space) -- | -- Wizard Coder 34B -- | -- Cowrite with llama2 -- | -- Image to Story -- | -- Clip interrogator 2 -- | -- Agent Benchmarks -- | -- AI Town Live Demo -- = -- AI Town Repository (Deployment]) -- | -- Generative Agents: Interactive Simulacra of Human Behavior (Research paper Repository) -- | -- IDEFICS - open Multimodal model -- | -- Belebele (Meta Dataset) -- | -- AI Comic Factory -- | -- CAMENDURU REPOS -- | -- SQL Dataset - A list of simple questions -- | -- Open Interpreter (alt to ChatGPT Pro) -- | -- List - Easy with AI -- | -- Whisper Web (UI) -- | -- Roblox Assistant -- | -- Illusion Diffusion (Hide words or shapes in the image) -- | -- Background replacement - Shopify -- | -- Lora The Explorer (SDXL) -- | -- InstaFlow (Under 1 second Inference) -- | -- TinyStories on mojo (230+ tk/s) -- | -- Any Emoji you want - emojijs -- | -- SDXL on TPUv5 -- | -- LCM - SD1.5 at 7secs per 4 images (after coldstart) -- | -- SDXL Control Lora -- | -- Whisper WebUI -- | -- AnimateDiff: Create an image make a video -- | -- Seamless m4t v2 -- | -- OtterHD: Multimodal model -- | -- Ego-exo4d Multimodal dataset -- | -- Meta Imagine images (Free) -- | -- Mage Space images (Free) -- | -- Bing Image Creator (Free) -- | -- Jay Alammar Blog - Illustrated Transformer, Stable Diffusion and More -- | -- OpenVoice - Open Source Voice Clone -- | -- Live-Vision HF Space - Live commentary on a video feed demo -- | -- Transformers JS demo - Xenova (HF) -- | -- Huggingface Assistants -- | -- 4-step SDXL Inference through LORA -- | -- Cosmopedia - 92 GB synthetic dataset made using Mixtral (25 billion tokens) -- | -- LGM-mini: image to ply -- | -- Playground v2.5 -- | -- OpenAI - Transformer Debugger -- | -- SWE-bench dataset (Real world github issues) -- | -- The Era of 1-bit LLMs - All Large Language Models are in 1.58 Bits -- | -- Microsoft Repo for AI research (Bitnet andd others will be here) -- | -- Realtime response using GroqCloud and live gradio interface -- | -- GroqCloud Application showcase -- | -- Open version of Open AI SORA -- | -- MMS (Meta) - TTS for 1000 languages -- | -- VoiceCraft (Audio Clone Model) -- | -- QuietStar Paper (HF) - Models linked -- | -- JAMBA - mamba based 52B with 140K context on one gpu!! -- | -- SDXS for realtime generation (upto 100FPS) -- | -- gguf-my-repo: HF space to create ggufs -- | -- LLAMA 3 release page (8, 70 and 400+) -- | -- AI Town running in HF -- | -- Nvidia AI Playground -- | -- Nemotron 4 340b - synthetic data generation assist -- | -- Huggingface Collections -- | -- Stable Diffusion 3 release -- | -- UDIO AI text to song generation -- | -- Lumalabs Video text to generation -- | -- OpenAI Interpretability (May/June 24) -- | -- OpenAI Sparse Autoencoder Repo -- | -- Anthropic Interpretability Posts Thread -- | -- Golden Gate Claude -- | -- Kling AI - SORA Competitor -- |
    """) with gr.Tabs() as nav1: with gr.Tab("Rep - HTML"): gr.HTML("UNWFWO = Unknown Native Word Foreign Word Order i.e. during active listening practice you only need the words you dont know | Closed Eye Recital per new word | 1 new word a minute while recycling the words from the previous minutes") gr.HTML("""""") with gr.Tab("Rep - Gradio"): gr.Interface(fn=group_words, inputs=groupinput_text, outputs=groupoutput_text, description="Word Grouping and Rotation - Group a list of words into sets of 10 and rotate them every 60 seconds.") #.queue() with gr.Tab("Navigation"): gr.HTML("Primary goal of this space is to help with memorisation --> Two main forms read or listen (rewriting is also an option for mission critical information - acronym map (too time comsuming))") gr.HTML("Picture Annotation
    Chorus Focused Word List
    Merged Subtitles
    Repetitive Audio (TTS)
    Word and Sentence Jumbling
    Unkown: Wordnet
    Unknown: Wikipeadia
    ") PracticeExposureInput = gr.Textbox("", placeholder="Exposure practice = look up", label="Exposure at the top") PracticeExposurebtn = gr.Button("Change Default") #Button CLick is defined under the variable it needs to manipulate to avoid undefined error gr.Button("Tab Navigation").click(TabNavigation, inputs=None, outputs=[nav1]) with gr.Tab("Words Lists"): gr.HTML("All links above can be turned into a glossary and then translated

    Stop, Sight(Dolch) and other Wordlists") gr.HTML("Wikipeadia
    Basic: -- Dolch (Sight) Words -- |
    Advanced: -- Blend Word -- | -- List_of_portmanteaus -- | ") gr.HTML("Reddit
    -- Wordplay -- | ") gr.HTML("Language Tests
    ") gr.HTML("Other
    -- English (StackExchange) -- | -- Overlapping Blends (StackExchange) -- | ") with gr.Tab("Vector Database = Memorisation"): gr.HTML("Phrasebook on demand in realtime

    Open AI - 10000 * 1000tokens (+- 4000 characters) = 1$ (0.0001 per 1000 tokens / 750 words), Cohere Multilingual = free for personal use / Commercial use = \n Vector Database query = Better than text search but not for logical relationships") with gr.Tab("Time Estimate Calculator"): gr.HTML("Repitition = A subconcious time gaame - transparent screens + below repitition assist (Vision) or (Audio)") gr.Interface(fn=RepititionPracticeTimeCalculator, inputs=["text", "number", "number"], outputs="text") with gr.Row(): PracticeExposure = gr.HTML(randomExposuremessage) PracticeExposure2 = gr.HTML(randomExposuremessage2) PracticeExposurebtn.click(fn=changeexposuretext, inputs=PracticeExposureInput, outputs=PracticeExposure) with gr.Row(): with gr.Column(scale=1): gr.HTML("Advanced Repitition = Combinatorics --> to understand a sentence properly you need understanding of every word --> in language that means use with other words --> Combos within the unique words in a sentence, paragraph, page, etc. --> as close to 3 word sentences") with gr.Column(scale=1): gr.HTML("

    Timing Practice - Repitition: Run from it, Dread it, Repitition is inevitable - Thanos --> Repitition of reaction - Foreign in eyes/ears native in mind (For beginners) | Repitition is a multitask activity like driving must be subconcious process to show mastery

    ") #----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- #----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- with gr.Column(scale=3): with gr.Tab("General Idea"): gr.HTML("Side by side reading creator (NLLB-600M (+-3gb / setting has 400 tokens? as max length for inference optimisation?)- 200 languages vs 107 in googletrans) - -- Fairseq Github -- | inspired by - -- Geonmo NLLB Demo -- | -- Vutuka demo -- ") with gr.Accordion("Chunk assist to avoid errors in nllb600m"): gr.Interface(fn=nllb_chunk_text, inputs=gr.Textbox(lines=5, placeholder="Enter your text here..."), outputs="text", title="Text Chunker", description="Enter your text and chunk it into segments of approximately 300 tokens.") with gr.Group(): gr.HTML("Under Construction - generator and cpu based to beat gpu cost, cpu wait time and network dependency for local use") nllbtranscpuinput = gr.Text(label="Paste Text you want to learn here (wordlists and UDHR can be used as )", placeholder="Enter Text Here") with gr.Row(): nllbtranscpubtnword4word = gr.Button("Create Side by Side Translation (FWNWO)") nllbtranscpulangsrc = gr.Dropdown(choices=nllb_lang_codes, label="Choose source language", value="English") nllbtranscpulangdest = gr.Dropdown(choices=nllb_lang_codes, label="Choose target language", value="Akan") #nllbtranscpuword4word = gr.Checkbox(label="word for word?") nllbtranscpubtn = gr.Button("Create Whole Translation (FWFWO)") gr.HTML("Placeholder for render function to auto load dropdown with chunks as input - Split by newline or spacy") with gr.Row(): with gr.Column(): #scale=4 nllbtranscpudetailsword4wordOutput = gr.Text(label="Side by side Inference Details", placeholder="Side by side Inference Details will display here") nllbtranscpuOutputword4word = gr.Text(label="Side by side", placeholder="Side by side will display here") nllbtranscpuaudioreadyformat = gr.Text(label="Audio ready format", placeholder="copy output to TTS to have listening practice material") with gr.Column(): nllbtranscpudetailsOutput = gr.Text(label="Inference Details", placeholder="Details will display here") nllbtranscpuOutput = gr.Text(label="Whole Translation of text", placeholder="Whole Translation will display here") with gr.Row(): with gr.Column(scale=2): nllbtranscpureversetranslationOutputword4word = gr.Text(label="Whole Translation of text", placeholder="Whole Translation to word for word will display here") with gr.Column(scale=1): nllbtranscpureversetranslationbtnword4word = gr.Button("Create Whole Translation side by side (NWFWO)") nllbtranscputotalhistoryOutput = gr.Text(placeholder="History nllb translations during this session should remain here") nllbtransrenderorderpracticePlaceholder = gr.HTML("Placeholder for render for practice without display format problems
    ") nllbtranscpuaudiomerged = gr.HTML("Code to save interleaved audio using two languages and save to single file
    ") nllbtranscpubtnword4word.click(fn=nllbtransctranslationoptionalw4w, inputs=[nllbtranscpulangsrc, nllbtranscpulangdest, nllbtranscpuinput], outputs=[nllbtranscpuOutputword4word, nllbtranscpudetailsword4wordOutput, nllbtranscputotalhistoryOutput]) nllbtranscpureversetranslationbtnword4word.click(fn=nllbtransctranslationoptionalw4w, inputs=[nllbtranscpulangdest, nllbtranscpulangsrc, nllbtranscpuOutput], outputs=[nllbtranscpureversetranslationOutputword4word, nllbtranscpudetailsword4wordOutput, nllbtranscputotalhistoryOutput]) nllbtranscpubtn.click(fn=nllbtransctranslation, inputs=[nllbtranscpulangsrc, nllbtranscpulangdest, nllbtranscpuinput], outputs=[nllbtranscpuOutput, nllbtranscpudetailsOutput, nllbtranscputotalhistoryOutput]) nllbtranscpuinput_text = gr.Textbox(label="Paste FWFWO or NWFWO to practice FWO") # Define a function with the @gr.render decorator @gr.render(inputs=nllbtranscpuinput_text) def nllbtrans_randomize_text(text): global nllbtrans_original_order words = text.split() if len(words) == 0: gr.Markdown("## No Input Provided") return [], [], [] nllbtrans_original_order = list(range(1, len(words) + 1)) random.shuffle(words) dropdowns = [] for word in words: dropdown = gr.Dropdown(choices=nllbtrans_original_order, label=word) dropdowns.append(dropdown) # columns = [] # for i in range(0, len(dropdowns), 10): # groupedcolumns = [] # for dropdown in dropdowns[i:i+10]: # groupedcolumns.append(gr.Column(dropdown)) # print(groupedcolumns) # columns.append(gr.Row(groupedcolumns)) #, equal_height=True))) # print(columns) columns = [] for i in range(0, len(dropdowns), 10): row_dropdowns = dropdowns[i:i+10] row = gr.Row() with row: for dropdown in row_dropdowns: gr.Column(dropdown) columns.append(row) # Check button to check the order check_button = gr.Button("Check Order") result = gr.Markdown("## Result will be shown here") check_button.click(nllbtrans_check_order, inputs=dropdowns, outputs=result) return columns + [check_button, result] gr.HTML("Side by side reading creator (Google Translate) TODO - Roman output of Non roman characters") with gr.Group(): with gr.Row(): #gr.Interface(fn=w4wsidebysidereadergen, inputs=["text", w4wsidebysidelangdest], outputs=["text", "text", "text"], description="Side by side reading creator") w4wsidebysideinput = gr.Text(label="Paste Text you want to learn here (wordlists and UDHR can be used as )", placeholder="Enter Text Here. One or Two Paragraphs at the longest ideally") with gr.Row(): w4wsidebysidelangdest = gr.Dropdown(choices=langdropdown_choices, label="Choose destination language", value="de: german") #w4wsidebysideaudiosidebyside = gr.Checkbox(label="Audio for side by side") w4wsidebysidebtn = gr.Button("Create Side by Side, FWNWO, and FWFWO (Just read start to finish of each till you can read the FWFWO without assistance)") with gr.Row(): w4wsidebysideOutput = gr.Text(label="Side by side", placeholder="Side by side will display here") w4wsidebysideFWNWOOutput = gr.Text(label="Foreign Word Native Word Order", placeholder="FW NWO will display here") w4wsidebysideFWFWOOutput = gr.Text(label="Foreign Word Foreign Word Order", placeholder="FW FWO will display here") with gr.Row(): w4wsidebysideaudioOutput = gr.Audio(sources=["upload"], label="Side by Side in Audio form") with gr.Row(): w4wsidebysideAnalysisPromptOutput = gr.Text(label="Prompt for LLM analysis", placeholder="Prompt for LLM analysis will display here") w4wsidebysidebtn.click(fn=w4wsidebysidereadergen, inputs=[w4wsidebysideinput, w4wsidebysidelangdest], outputs=[w4wsidebysideOutput, w4wsidebysideFWNWOOutput, w4wsidebysideFWFWOOutput, w4wsidebysideaudioOutput, w4wsidebysideAnalysisPromptOutput]) with gr.Row(): gr.HTML("To be Added") with gr.Row(): w4wsidebysideNatSentStructOutput = gr.Text(label="Native Closed class words as Native Sentence Structure", placeholder="Comparison is valuable") w4wsidebysideForSentStructOutput = gr.Text(label="Foreign Closed class words as Foreign Sentence Structure", placeholder="Comparison is valuable") with gr.Row(): w4wsidebysideWordCountOutput = gr.Text(label="Word Count", placeholder="Word Count will display here") w4wsidebysideRandomisedOutput = gr.Text(label="Random Order As Test", placeholder="Randomised version (Transition Tab most left bottom) will display here") w4wsidebysideQueGenOutput = gr.Text(label="Questions generation as comprehension test", placeholder="Questions generated will display here") w4wsidebysideUNWFWOOutput = gr.Text(label="HTML as UNWFWO assistant", placeholder="HTML as UNWFWO assistant download will display here") with gr.Tab("Reading and Grammar Assistance"): gr.HTML("Under time pressure (foreign text takes very long) the chance of just scanning the text goes up, below assists with reading the current line") with gr.Tab("General - Notetaking Reader"): gr.HTML("Placeholder for render based reader - Still incomplete as the inputs need to be stored as seperate items to allow sending output to the right place") gr.HTML("Ideas to add back to the general reader
    Analytics - count the length of the text in the note fields
    Add a maslows hierachy textbox
    critical thinking texbox
    add a chunk reference field
    Code to fit the theme
    Words in songs / youtube videos you have collected to one file") gr.HTML("Placeholder for the rake interface") autoprocessrender_pdf_input = gr.File(label="Upload PDF", type="filepath") autoprocessrender_text_input = gr.Textbox(label="Paste Text Here", lines=10) autoprocessrender_text_file_input = gr.File(label="Upload Text File", type="filepath") autoprocessrender_chunks_output = gr.Markdown(label="Chunks will be displayed here") @gr.render(inputs=[autoprocessrender_pdf_input, autoprocessrender_text_input, autoprocessrender_text_file_input]) def autoprocessrender_display_chunks(pdf_file=None, pasted_text=None, text_file=None): chunks = [] if pdf_file: chunks = autoprocessrender_handle_pdf(pdf_file.name) elif pasted_text: chunks = autoprocessrender_split_text_into_chunks(pasted_text) elif text_file: chunks = autoprocessrender_handle_text_file(text_file) notes = [] ai_notes = [] if not chunks: return gr.Markdown("## No text provided or extracted"), [], [], [] else: chunk_elements = [] for chunk in chunks: chunk_textbox = gr.Textbox(value=chunk, label="Chunk", interactive=False) chunk_pos_html = gr.HTML(value=chunk, label="Chunk POS") notes_textbox = gr.Textbox(label="Notes") words_ending_in_s = autoprocessrender_find_words_ending_in_s(chunk) words_textbox = gr.Textbox(value=", ".join(words_ending_in_s), label="Words ending in 's'", interactive=False) ai_notes_textbox = gr.Textbox(label="AI Notes") def add_ai_notes(chunk=chunk, ai_notes_textbox=ai_notes_textbox): ai_notes = autoprocessrender_generate_ai_notes(chunk) ai_notes_textbox.update(value=ai_notes) return ai_notes ai_notes_button = gr.Button("AI Notes").click(add_ai_notes) chunk_elements.append(gr.Column([chunk_textbox, notes_textbox, words_textbox, ai_notes_textbox, ai_notes_button])) notes.append(notes_textbox) ai_notes.append(ai_notes_textbox) def save_all_text_action(notes=notes, ai_notes=ai_notes): all_text = autoprocessrender_save_all_text(chunks, [note.value for note in notes], [ai_note.value for ai_note in ai_notes]) return gr.File.update(value=all_text.encode('utf-8'), filename="all_text.txt") save_button = gr.Button("Save All Text") save_button.click(save_all_text_action) return gr.Column(chunk_elements), notes, ai_notes, save_button with gr.Tab("Focus based reader"): gr.HTML("Focus in this cotext = Stare at one spot OR Track through multiple instances (different starting points)") focusreaderinput = gr.Textbox(placeholder="Enter text here") with gr.Row(): focusreaderinputbtnclear = gr.Button("Clear Output") focusreaderinputbtn = gr.Button("Load single focus Text") focusreaderinputbtn2 = gr.Button("Load multiple focus Text") focusreaderoutput1 = gr.HTML("") focusreaderoutput2 = gr.HTML("") focusreaderoutput3 = gr.HTML("") focusreaderoutput4 = gr.HTML("") focusreaderinputbtnclear.click(fn=clearfocusreadertext , outputs=[focusreaderoutput1, focusreaderoutput2, focusreaderoutput3, focusreaderoutput4]) focusreaderinputbtn.click(fn=singlefocusreadertext , inputs=[focusreaderinput], outputs=[focusreaderoutput1, focusreaderoutput2, focusreaderoutput3, focusreaderoutput4]) focusreaderinputbtn2.click(fn=multifocusreadertext , inputs=[focusreaderinput], outputs=[focusreaderoutput1, focusreaderoutput2, focusreaderoutput3, focusreaderoutput4]) with gr.Tab("Parts Of Speech based Reader"): gr.HTML(" Vague Words = generalisation format = reasoning pattern? Someone went somewhere then did something in multiple domains? ") with gr.Tab("Partial Foreign Translate"): gr.HTML("Types of verbs and their purpose") gr.HTML("Closed class words provide some reasoning logic") gr.Interface(fn=partial_NWOtranslate_closed_class_words, inputs=["text", "checkbox"], outputs=["text"], description="partial translation test (german) for reading assist") with gr.Tab("Beginner - Vague Language and Guessing POS"): with gr.Row(): gr.HTML("Some Vague Words - Quantifiers, Pronouns, etc.

    Very, Many, Few, Lots,
    Lets add 40 words to this list
    Find Replace all nouns with something/someone or and for verbs figure out how to generalise them") gr.HTML("Parts of speech recognition = comprehension
    Three word sentences will give a easier guessing chance") gr.HTML('') with gr.Tab("Thinking Practice (POS)"): gr.HTML("Ability to Part of Speech tag is end goal (SOV, SVO, VSO) as that is where guessing the meaning starts") gr.HTML("By removing all nouns and verbs you get a format to practice thinking about your words to use to make sentences which make sense within constraints") gr.HTML(" -- SQL Dataset - A list of simple questions -- |") gr.Textbox(label='Use this text to hold translations of the SQL rows in the above linked dataset (A kind of What I say vs what I want)') with gr.Tab("Custom Formated HTML Output"): with gr.Tab("UNWFWO - Stateful Reading - Progress Tracking"): gr.HTML("The problem is to learn you need to repeat things you know that you didnt know this morning - Repititionis only half of solution
    You need to read new stuff while revising the stuff you didnt know that you just learned aka the things you write as notes
    Blended Images can help") gr.Interface(fn=UnknownTrackTexttoApp, inputs="text", outputs=["file", "html", "code"], description="HTML mini App - UNNWFWO (English grammar only for now)(To track verbs you dont know for listening practice). Use the text from here to create lists you use for the TTS section") gr.HTML("The sentences used as notes repitition interface then can count as recently known sentences that you can ignore in favour of the sentences you didnt interact with") gr.Label("Some Tests - click to hide - unknown word only list") gr.HTML("------------INCOMPLETE (javascript doesnt and unhide proprely)------------------------") gr.Interface(fn=hidingbuttontesttranslate, inputs="text", outputs=["code", "html"]) gr.HTML("On the Acronyms you need to underline the verbs") gr.HTML("Aim for 1000 reps per item in your mind - the end goal for full sentences is to identify the SOV equivalent ASAP") with gr.Tab("Image based reading"): gr.Interface(fn=imagebasedreading, inputs=["text"], outputs=["file", "html", "text"], title="Placeholder for every newline") with gr.Tab("Reading Assitant + Unknown Tracker"): gr.HTML("Some Tools -- Microsoft Immersive Reader (Comprehension) -- | LingQ - (Word Familiarity based) | -- Infranodus - Word Level Knowledge graphs -- ") gr.Interface(create_acronym_map, inputs='text', outputs=['text', 'text'], description="Acronym Map Generator (per line) - Index and Memorisation Practice Tool") gr.HTML("Repitition of things you know is a waste of time when theres stuff you dont know

    In Language the first goal is bigger vocab --> Knowledge equivalent = question answer pairs but to get to those you need related information pairs

    Vocab = Glossary + all non text wall(lists, diagrams, etc.)

    ") gr.Textbox("Placeholder for a function that creates a set list and can takes a list for known words and auto find replaces the stuff you know out of the content") gr.HTML("Place holder for a translate to english interface so that highlighting can still work as only english supported for now - -- Google Translate -- ") gr.Label("Unique word ID") gr.Interface(fn=unique_word_count, inputs="text", outputs="text", description="Wordcounter") gr.HTML("Use the below interface to fill in the space in this format and then use the chat iframe at the top to ask llm to analyse this:

    Consider how the following sentence meaning will change if the each if the selected word is replaced with one hypernym at a time:
    Sentence:
    Hypernyms: ") gr.Interface(fn=SepHypandSynExpansion, inputs="text", outputs=["text", "text"], description="Word suggestions - Analyse the unique words in infranodus") gr.Interface(fn=WikiSearch, inputs="text", outputs="text", description="One word at a time Unique word suggestions (wiki articles)") with gr.Tab("Automating related information linking"): gr.HTML("Questions - Taking and suggesting questions to ask = new education --> Esp. Infranodus type outer discourse identification as question generation") gr.HTML("The point of reading is to refine future actions especially problem solving --> Creating problem scenarios = thinking ahead of time = One form of effective reading") with gr.Tab("Notetaking ideas"): with gr.Tab("Advanced - Making Questions = Reading"): gr.HTML("Some Example Prompts (Even Mistral 7b is good at this)

    Please make a comprehension test for the following:
    Please make 10 questions baseed on this text:
    ") with gr.Row(): gr.TextArea("Paste the text to read here", interactive=True) gr.TextArea("Make as many questions on the text as you can in native language and then translate", interactive=True) gr.Dropdown(["Placeholder chunk 1", "Placeholder chunk 2", "Placeholder chunk 3"]) gr.HTML("Load the current chunk here and Put a Dataframe where you have only one column for the questions") gr.HTML(""" Some considerations for questions to make Please continue this sentence Types of knowing something = verbatim recall, differences, characteristics, definition of the item, definitions of the items related

    Mistral-Medium: Sure! Here are some additional types of knowing something: Causes and effects: Understanding the causes and effects of a concept or phenomenon can help deepen your knowledge and make it more applicable to real-world situations. Examples and non-examples: Providing examples and non-examples of a concept can help clarify its meaning and distinguish it from similar concepts. Analogies and metaphors: Using analogies and metaphors can help make abstract concepts more concrete and easier to understand. Principles and theories: Understanding the principles and theories that underlie a concept can help you see how it fits into a broader framework of knowledge. Applications and implications: Understanding the practical applications and implications of a concept can help you see its relevance and importance in real-world contexts. Historical and cultural context: Understanding the historical and cultural context in which a concept developed can provide valuable insights into its meaning and significance. Overall, there are many different types of knowing, and each one can contribute to a more complete and nuanced understanding of a topic. By using a variety of approaches and strategies, you can deepen your knowledge and improve your ability to apply it in meaningful ways.

    GPT-4 Turbo: Please continue this sentence Types of knowing something = verbatim recall, differences, characteristics, definition of the item, definitions of the items related Types of knowing something can include verbatim recall, understanding differences, recognizing characteristics, defining the item, and understanding definitions of related items. Beyond these aspects, knowing can also encompass: Application: The ability to use the information in new and concrete situations. This involves applying rules, methods, concepts, principles, laws, and theories. Analysis: The capability to break down material into its constituent parts and understand its organizational structure. This includes recognizing the relationships between the parts and the overall structure and purpose. Synthesis: The skill to put parts together to form a new whole. This could involve creating a new pattern, proposing alternative solutions, or deriving a new set of abstract relations. Evaluation: Making judgments about the value of ideas or materials. This requires forming opinions and making decisions based on criteria and standards through checking and critiquing. Procedural Knowledge: Knowing how to do something, which involves procedural steps or actions required to perform a task or solve a problem. Conditional Knowledge: Understanding when to use certain knowledge, which involves recognizing the applicability of a skill or concept in various contexts. Metacognitive Knowledge: This is a higher-order type of knowing, which involves awareness and understanding of one's own thought processes. It includes the ability to monitor, regulate, and direct oneself to a desired end, like learning or problem-solving. Tacit Knowledge: This is the kind of knowledge that is difficult to transfer to another person by writing it down or verbalizing it. It is acquired through personal experience and context, often without conscious awareness. Explicit Knowledge: In contrast to tacit knowledge, explicit knowledge is that which can be articulated, codified, accessed and verbalized. It can be readily transmitted to others. Intuitive Knowledge: This refers to understanding or believing something instinctively without the need for conscious reasoning. It's often experienced as a 'gut feeling' or an 'aha' moment that comes seemingly out of nowhere. Each type of knowing involves different cognitive processes and levels of understanding. The depth and breadth of one's knowledge often depend on the ability to combine these various types of knowing effectively. """) with gr.Tab("Knowledge Ideas - Notetaking"): gr.HTML("""

    Good knowledge = ability to answer questions --> find Questions you cant answer and look for hidden answer within them

    My One Word Theory = We only use more words than needed when we have to or are bored --> Headings exist because title is not sufficient, subheadings exist because headings are not sufficient, Book Text exists because subheadings are not sufficient

    Big Picture = Expand the Heading and the subheadings and compare them to each other

    Application of Knowledge = App Version of the text (eg. Jupyter Notebooks) is what you create and learn first

    """) gr.Label('Placeholder for LLM api plus the drop down function below populate text for each line into dropdowns') gr.Interface(fn=TextCompFormat, inputs=["textarea", HTMLCompMode], outputs="text", description="Convert Text to HTML Dropdown or Links which you paste in any html file") gr.Interface(fn=create_collapsiblebutton, inputs=["textbox", "textbox", "textarea"], outputs="textbox", description="Button and Div HTML Generator, Generate the HTML for a button and the corresponding div element.") with gr.Tab("Repetition Injected Text"): gr.Label("Optimal Study Reps is inbetween new information acquisition - i.e. any thing you havent read already") gr.Interface(fn=RepititionInjectedReading, inputs=[Repsplitdropdown, "text", "text"], outputs="text") with gr.Tab("Graph Based Reading", id="1"): gr.Textbox('Parts of Speech based | Automating the Notetaking Tab either directly or using visual llm to use this interface efficiently') gr.HTML("Types of comprehension agent
    Speed of Comprehension = Verb comprehension
    From the following please extract the verbs
    now explain each in context
    Next, use picture descriptions for each word in the verb list
    Create combinations using the verb list
    ") gr.HTML("How VERBS RELATE TO EACH OTHER --> Shared Nodes - what other verbs are connected to the noun in a INFRANODUS With POS Tag filters") gr.HTML("Tree and Branches approach to learning = familiarity with keywords/headings/summaries before reading the whole text
    Productivity/Work revolves around repitition which can be found looking for plurals and grouping terms eg. Headings and Hyper/Hyponyms Analysis") gr.HTML("Sentence to PyDot graph") gr.HTML("Currently a bug that locks all buttons in the space when you use this above example - Reload to fix") with gr.Tab("Long Text Analysis"): gr.HTML("For Long text searches are useful under time pressure and also bring all direct interactions with search terms - a word is defined by those around it") gr.Label("Placeholder for old code for concordance and word counting in other test space") with gr.Tab("Some Sample Texts"): gr.HTML("One way to optimise reading is to quickly find the ideas that allow making decisions after
    Hardcoded closed class translation
    Ways for AI to transform the text (Groq can do all instantly at the same time) - Glossary, Questions, IPO patterns, Relative Meaning(Maslows, Products) Plural item extraction, Verbs Extraction, Documents related to the text in any related academic field.
    ") gr.Interface(fn=LoadNLTKUDHRText, inputs=NLTKudhr, outputs=["text", "textarea"], description="UDHR as some test texts") gr.Interface(fn=GuidedReading, inputs=["text", guidedreadingseperator], outputs="text", description="Manual POS Tag and Transliteration", examples=textspreprocess) with gr.Tab("Real-Time - Vid/Aud/AR"): gr.HTML("24/7 immersion with segmentation and realtime responses overlayed over your display - Commentary in real time. What is the relative ideas to sports commentary in work, school and life in general?
    Currently Google Translate with live translation overlay | GPT4o = Customisable | -- OpenGPT4o by KingNish -- to a nllb interface ") with gr.Accordion("Test continuous data collect", open=False): SvelterealtimedebugSpaceLink = gr.Textbox("https://kwabshug-realtimedebugtestsveltevitestatic.static.hf.space") SvelterealtimedebugSpacetest = gr.HTML("") SvelterealtimedebugSpacetestbtn = gr.Button('Load Space') SvelterealtimedebugSpacetestbtn.click(display_website, SvelterealtimedebugSpaceLink, SvelterealtimedebugSpacetest) gr.Interface(fn=ImageTranslationTest , inputs=[VideoTestInput, VideoTestSubtitleInput], outputs="video") gr.Interface(fn=segment_video_with_opencv, inputs=VideoSplitTestInput, outputs=SplitVideoOutput, description="Split video into even increments for better study tracking ") with gr.Accordion("Image Annotation Ideas", open=False): gr.HTML("""Reading - Caption images (SD/Dalle-E)
    -- Unsplash - free images -- | --Huggingface CLIP-Interrogator Space-- | -- Clip interrogator 2 -- | -- Tag2Text is faster than clip -- |
    -- Transform word to an image -- | -- Promptist (Microsoft) -- | -- RAM and Tag2Text -- | -- SAM with Clip -- """) with gr.Accordion("RAM/Tag2Text Space - Create Tags here and Copy paste", open=False): RAMSpaceLink = gr.Textbox("https://xinyu1205-recognize-anything.hf.space") RAMSpacetest = gr.HTML("") RAMSpacetestbtn = gr.Button('Load Space') RAMSpacetestbtn.click(display_website, RAMSpaceLink, RAMSpacetest) with gr.Accordion("Grounded SAM Space Test", open=False): SAMSpaceLink = gr.Textbox("https://linfanluntan-grounded-sam.hf.space") SAMSpacetest = gr.HTML("") SAMSpacetestbtn = gr.Button('Load Space') SAMSpacetestbtn.click(display_website, SAMSpaceLink, SAMSpacetest) gr.HTML("Use Shift Enter To put text on new lines if the text doesnt fit
    if theres an error you have to remove the foreign letters and place roman ones") gr.Interface(fn=add_text_to_image , inputs=["image", "text"], outputs="image", description="Create Annotated images (Can create using stable diffusion and use the prompt) - Describe from one side to the other to make guessing easy") gr.Textbox("Placeholder - Alpha Test version = Real time Lablling of All things in view using SAM and Clip Interrogator and OpenCV on pydroid --> Adjusted Demo") with gr.Accordion("Old ideas to understand around a buffer", open=False): gr.HTML("Steerable Surveillance system = Assistant --- people will need to manage their own infrastructure or risk total invasion of privacy") gr.HTML("Cheap: Raspberry Pi / Pydroid and OpenCV and Tkinter = Frontend for LMM API
    Expensive - XREAL Air 2, Quest 3, Vision Pro, ") gr.HTML("HUD Experiment (Waiting for GPT4V API) - Full context of user situation + Ability to communicate in real-time to user using images (H100+ and low enough resolution and low enough steps - it/s = fps) - just like google maps but for real life") gr.HTML("Audio: https://github.com/OpenInterpreter/01 for commands
    Some sample Open Interpreter Code - https://huggingface.co/spaces/ysharma/open-interpreter/blob/main/app.py") gr.HTML("Nicolai Nielsen Youtube channel (Tutorial) - aruco markers = position --> Preplanned responses esp paired with openinterpreter") gr.HTML("Image Understanding Spaces links can found at the top of this space
    Video Dubbing - -- artificialguybr's video transcription space -- |") gr.HTML("Some Prompt ideas --> Prompt: Describe the place where these descriptions may be (You job is to be speculative for brainstorming purposes): A dog and a boy, the area is texas, the weather is sunny, the date is 01 May 2021
    Prompt Content Ideas Ideas Clip Interrogator + Location Data aka tags for place, location and time + general news updates on the location + overview of the items in the location
    Location based advise is most important but after that is information observed by appliances in the location eg. Times Computer turned on, times geyser inspected, amount of time keys havent been touched etc.
    each location will have an ai personality that will relay more information ") with gr.Tab("Order Based Audio"): with gr.Tab("Audio Generation"): gr.Interface(fn=TTSforListeningPractice, inputs=["text", TTSLangOptions, "checkbox"], outputs="audio", description="gTTS - Paste chorus lyrics from below here and use TTS or make notes to save here (Or paste anything)") gr.Label("Audio - Only English thoughts as practice") gr.HTML("For Audio Most productive is real time recall of native (where your full reasoning ability will always be)
    Find Replace new lines of the foreign text with full stops or | to get per word translation") gr.Interface(fn=TTSforListeningPractice, inputs=["text", TTSLangOptions2], outputs="audio", description="Paste only english words in foreign order and then keep removing the words from this to practice as effectively") with gr.Tab("Audio Format Brainstorming"): with gr.Accordion("Explanation of below brainstorm outputs", open=False): gr.HTML("Explanation of the outputs of the merged interface - FrontRevSentChunkbrainstormoutput, AutoSyllablePracticebrainstormoutput, RandomiseTextbyTypebrainstormoutput, create_dictionarybrainstormoutput, keep_nouns_verbsbrainstormoutput, split_verbs_nounsbrainstormoutput[0], split_verbs_nounsbrainstormoutput[1], split_verbs_nounsbrainstormoutput[2], SimultaneousSpellingPracbrainstormoutput, FirstLetterSummarybrainstormoutput, AutoChorusPerWordSchedulerbrainstormoutput") gr.HTML("Acronym cant be read without previous attentive reading - accurate measure of known vs unknown, example LLM prompt - Please help me study by making a acronym map for the maths ontology (Ask if theres questions) --then-- Good but we need to now create a 9 Acronym based words - 1 for the headings together and then one each for the subheadings") with gr.Tab('Acronym Map Creation Space'): with gr.Accordion('Test with LLM'): gr.Label('Letters are always easier to recall than whole words. GPT 4 and above best suited for this prompt but can test anywhere') gr.HTML('Please help me study by making a acronym map for the maths ontology (Ask if theres questions)') gr.TextArea('', label='Paste LLM response') gr.HTML('Good but we need to now create a 9 Acronym based words - 1 for the headings together and then one each for the subheadings') gr.TextArea('', label='Paste LLM response') gr.HTML('If study content was a map the first letters shape of the whole text = Roads') gr.HTML('Known = ability to match an item to a retrieval cue instantly - Retrieval cue for the whole text = Acronym Map') gr.Interface(fn=audioformatbrainstorm, inputs=[ChunkModeDrop, "checkbox", "text", langdest, RandomiseTextType], outputs=["text", "text", "text", "text", "text", "text", "text", "text", "text", "text", "text"], description="Many random ideas to reorder text for testing / practice") gr.Interface(fn=lambda sentence: ". ".join(sentence.split()), inputs=["text"], outputs=["text"], description="Use full stops before input below to make a world level version") gr.Interface(fill_lines, inputs=["text", RepSched_Num_lines], outputs="text") with gr.Accordion("Merged to one interface", open=False): gr.Interface(fn=FrontRevSentChunk, inputs=[ChunkModeDrop, "checkbox", "text", langdest], outputs="text", description="Chunks creator") gr.Interface(fn=AutoSyllablePractice, inputs="text", outputs="text", description="One Word At A Time | Audio Spelling Practice Using vowels as the seperator") gr.Textbox("A word is a list of letter as a fact is a list of words. Both are in a specific order. What is most important is practice the order so randomiser is the tool", lines=4) gr.Interface(fn=RandomiseTextbyType, inputs=["text", RandomiseTextType], outputs="text", description="Randomise order within words, sentences, paragrahs") gr.Textbox("Merged Spelling Practice Placeholder - Spell multiple words simultaneously for simultaneous access", lines=3) gr.HTML("

    Spell multiple words simultaneously for simultaneous access

    Spelling Simplification - Use a dual language list? | Spelling is the end goal, you already know many letter orders called words so you need leverage them to remember random sequences") gr.Interface(fn=create_dictionary, inputs="text", outputs="text", title="Sort Text by first two letters") gr.Interface(fn=keep_nouns_verbs, inputs=["text"], outputs="text", description="Noun and Verbs only (Plus punctuation)") gr.HTML("Below you can create and listen to the audio") gr.Interface(fn=SimultaneousSpellingPrac, inputs=["text"], outputs=["text"], title="Simultaneous SpellingOrder fast fast practice --> 1 letter a word = fastest read") gr.Interface(fn=FirstLetterSummary, inputs=["text"], outputs=["text"], title="Order fast fast practice --> 1 letter a word = fastest read") with gr.Tab("Sentence to Practice Format"): gr.Interface(fn=split_verbs_nouns , inputs="text", outputs=["text", "text", "text"], description="Comprehension reading and Sentence Format Creator") with gr.Tab("Song Based"): gr.HTML("Listening - Songs - Chorus
    Anticipation of the item to remember is how you learn lyrics that is why songs are easy as if you heard it 10 times already your capacity to anticipate the words is great

    This is where TTS helps as you are ignoring all words except the words just before the actual
    Tiny Stories dataset is like a graded reader
    ") gr.HTML("

    Fastest way to learn words = is to have your own sound reference --> probably why babies learn fast as they make random noise

    If you know the flow of the song you can remember the spelling easier

    Essentially if the sounds are repeated or long notes they are easy to remember

    ") gr.Interface(fn=AutoChorusInvestigator, inputs="text", outputs="text", description="Paste Full Lyrics to try find only chorus lines") with gr.Tab("Sentence Builder - Markov Collocation based"): with gr.Row(): with gr.Column(scale=1): gr.HTML("Markov generatioon only based on words you do or dont know? - delete the keys for the direction you need after text corpus analysed") gr.HTML("Markov generatioon only based on One Youtube videos transcripts or one artist / creative") with gr.Column(scale=3): gr.HTML("Transition is the true nature of logic i.e. like some form of non-semantic embedding that is semantic?") gr.Interface(fn=build_model, inputs="text", outputs=["text", "text"], description="Create Collocation Dictionary --> Google Kathryn Lingel - Pyambic Pentameter Example - PyCon US for more") gr.Interface(fn=markov_generate, inputs=["text", Markovlength], outputs="text", description="Generate Text based on the collocations in the text") with gr.Tab("Sentence Builder - Preprogrammed"): gr.HTML("Claude 3 assited ideas and code") with gr.Tab("Diary based?"): gr.HTML("Sentence based on the activities of the day in order?") with gr.Tab("Basic Sentence Builder"): with gr.Tab("SVO"): gr.Markdown( """ ## Subject-Verb-Object (SVO) Order Some languages that follow the SVO order: - English - Spanish - French - Italian - Chinese """ ) svo_subject = gr.Dropdown(sentbuildsubjects, label="Subject") svo_verb = gr.Dropdown(sentbuildverbs, label="Verb") svo_object = gr.Dropdown(sentbuildobjects, label="Object") svo_output = gr.Textbox(label="Sentence (SVO)") svo_btn = gr.Button("Generate SVO Sentence") svo_btn.click(build_sentence_basic, inputs=[svo_subject, svo_verb, svo_object, gr.State("SVO")], outputs=svo_output) with gr.Tab("SOV"): gr.Markdown( """ ## Subject-Object-Verb (SOV) Order Some languages that follow the SOV order: - Japanese - Korean - Turkish - Hindi - Latin """ ) sov_subject = gr.Dropdown(sentbuildsubjects, label="Subject") sov_object = gr.Dropdown(sentbuildobjects, label="Object") sov_verb = gr.Dropdown(sentbuildverbs, label="Verb") sov_output = gr.Textbox(label="Sentence (SOV)") sov_btn = gr.Button("Generate SOV Sentence") sov_btn.click(build_sentence_basic, inputs=[sov_subject, sov_verb, sov_object, gr.State("SOV")], outputs=sov_output) with gr.Tab("VSO"): gr.Markdown( """ ## Verb-Subject-Object (VSO) Order Some languages that follow the VSO order: - Arabic - Hebrew - Irish - Welsh - Samoan """ ) vso_verb = gr.Dropdown(sentbuildverbs, label="Verb") vso_subject = gr.Dropdown(sentbuildsubjects, label="Subject") vso_object = gr.Dropdown(sentbuildobjects, label="Object") vso_output = gr.Textbox(label="Sentence (VSO)") vso_btn = gr.Button("Generate VSO Sentence") vso_btn.click(build_sentence_basic, inputs=[vso_subject, vso_verb, vso_object, gr.State("VSO")], outputs=vso_output) with gr.Tab("Complex Sentence Builder"): gr.Markdown( """ ## Complex Sentence Builder Create intricate sentences using various grammatical components. """ ) complex_subject = gr.Dropdown(sentbuildsubjects, label="Subject") complex_verb = gr.Dropdown(sentbuildverbs, label="Verb") complex_object = gr.Dropdown(sentbuildobjects, label="Object") complex_adjective = gr.Dropdown(sentbuildadjectives, label="Adjective") complex_adverb = gr.Dropdown(sentbuildadverbs, label="Adverb") complex_prep_phrase = gr.Dropdown(sentbuildprep_phrases, label="Prepositional Phrase") complex_conjunction = gr.Dropdown(sentbuildconjunctions, label="Conjunction") complex_structure = gr.Radio(sentbuildchoices, label="Structure") complex_output = gr.Textbox(label="Complex Sentence") complex_btn = gr.Button("Generate Complex Sentence") complex_btn.click(build_sentence, inputs=[complex_subject, complex_verb, complex_object, complex_adjective, complex_adverb, complex_prep_phrase, complex_conjunction, complex_structure], outputs=complex_output) with gr.Tab("Quiz"): # ... (Quiz tab remains the same) gr.Markdown( """ ## Sentence Order Quiz Test your knowledge of sentence orders by identifying the correct order for each given sentence. """ ) quiz_sentence = gr.Textbox(label="Sentence") quiz_question = gr.Textbox(label="Question") quiz_choices = gr.Radio(["SVO", "SOV", "VSO"], label="Options") quiz_answer = gr.Textbox(label="Answer") quiz_feedback = gr.Textbox(label="Feedback") quiz_button = gr.Button("Generate Quiz Question") quiz_button.click(sentbuildgenerate_quiz_question, inputs=[], outputs=[quiz_sentence, quiz_question, quiz_choices, quiz_answer]) submit_button = gr.Button("Submit Answer") submit_button.click(sentbuildcheck_answer, inputs=[quiz_choices, quiz_answer], outputs=[quiz_feedback, submit_button]) with gr.Tab("Conlangs"): gr.HTML("What process goes into making a language? - one place to look https://www.reddit.com/r/conlangs/") gr.HTML("Conlang as a study method? Make a mixed language of all target languages? Something inspired by esperanto?") with gr.Tab("Vision based"): with gr.Tab("Youtube Subs Listening Comprehension"): gr.HTML("State Management Solution for Word --> Find LingQ Here --> https://www.lingq.com/en/") with gr.Tab("New - Learning with Youtube"): gr.HTML("TODO: 1st syllable subtitle. First Syllable of any word is all you need to listen - pair this with Youtube subtitle interface - Listening is ability to spell really fast (real time)") gr.HTML(" -- artificialguybr's Video Translation/Transcription Space -- | ") with gr.Group(): gr.HTML("Custom Subtitles Ideas - Realtime Practice = Test (Pause to learn)") YTTransciptOutDropdown = gr.Dropdown(choices=["https://www.youtube.com/watch?v=l8pRSuU81PU", "https://www.youtube.com/watch?v=UYk43fncV68", "https://youtu.be/dxVaP0-aFIE"], value="https://www.youtube.com/watch?v=UYk43fncV68", allow_custom_value=True) YTTransciptOutbtn = gr.Button("Transcript to text") YTTransciptOutVid = gr.HTML('Video will load Here') gr.Interface(fn=subtitle_generator, inputs=None, outputs=["textbox", "textbox", "textbox"], description='Modified Subtitles Test - will only work after video has been loaded') with gr.Row(): with gr.Column(scale=4): with gr.Row(): YTTransciptAnalysedOut = gr.Textbox(placeholder="Place the translated transcript here (Click on the youtube logo to open the video and copy)") with gr.Row(): YTTransciptOut = gr.Textbox(placeholder="Place the translated transcript here (Click on the youtube logo to open the video and copy)") with gr.Column(scale=1): YTTransciptTextOnlyOut = gr.Textbox(placeholder="Place the translated transcript here (Click on the youtube logo to open the video and copy)") YTTransciptOutbtn.click(fn=YTTransciptAnalysisandLoad, inputs=YTTransciptOutDropdown, outputs=[YTTransciptOutVid, YTTransciptOut, YTTransciptAnalysedOut, YTTransciptTextOnlyOut]) with gr.Tab("Old - Visual - Multiline Custom Video Subtitles"): gr.HTML("------------------------ INCOMPLETE (Somewhere around the SRT merging and merging process) -------------------------------------") gr.HTML("LingQ Companion Idea - i.e. Full Translation Read along, and eventually Videoplayer watch along like RAMUS whisper space

    Extra functions needed - Persitent Sentence translation, UNWFWO, POS tagging and Word Count per user of words in their account. Macaronic Text is also another way to practice only the important information") gr.HTML("""

    For Transcripts to any video on youtube use the link below ⬇️

    https://huggingface.co/spaces/RASMUS/Whisper-youtube-crosslingual-subtitles | https://huggingface.co/spaces/vumichien/whisper-speaker-diarization""") #gr.HTML("

    If Space not loaded its because of offline devopment errors please message for edit

    ") with gr.Tab("Merged Subtitles (Incomplete)"): gr.HTML(""" Core Idea = Ability to follow one video from start to finish is more important than number of words (except for verbs)
    Step 1 - Get foreign transcript - WHISPER (Need to download video though - booo) / Youtube / Youtube transcript api / SRT websites
    Step 2 - Get Translation of foreign transcript
    Step 3 - Word for Word Translation Creation in both Directions (Paste Google Translation here)
    """) gr.Interface(fn=split_srt_file, inputs=["text", SRTLangOptions] , outputs=["text", "file", "text", "text"], description="SRT Contents to W4W Split SRT for Google Translate") gr.Interface(fn=chunk_srt_text, inputs=['text', Translationchuncksize], outputs=['dataframe','text'], description='Assitant for google translate character limit - aka where to expect cuts in the text') gr.HTML("Step 4 - Pronounciation (Roman) to Subtitle Format --> GTranslate returns unformatted string") gr.Interface(fn=splittext, inputs="text", outputs="text", description="Text for w4w creation in G Translate") gr.HTML("Step 5 - Merge into one file") with gr.Row(): RomanFile = gr.File(label="Paste Roman") W4WFile = gr.File(label="Paste Word 4 Word") FullMeanFile = gr.File(label="Paste Full Meaning") MacaronicFile = gr.File(label="Paste Macaronic Text") SentGramFormula = gr.File(label="Paste Sentence Grammar Formula Text") with gr.Row(): MergeButton = gr.Button('Merge the seperate files into one interpolated file (Line by line merge)', ) with gr.Row(): MergeOutput = gr.TextArea(label="Output") MergeButton.click(merge_lines, inputs=[RomanFile, W4WFile, FullMeanFile, MacaronicFile], outputs=[MergeOutput], ) with gr.Row(): gr.Text("Make sure there are 4 spaces after the last subtitle block (Otherwise its skipped)") CleanedMergeButton = gr.Button('Create a Usable file for SRT') with gr.Row(): CleanedMergeOutput = gr.TextArea(label="Output") CleanedMergeButton.click(fn=SRTLineSort, inputs=[MergeOutput], outputs=[CleanedMergeOutput]) with gr.Tab("Split video to segments"): gr.HTML("How to make screenshot in vlc - https://www.vlchelp.com/automated-screenshots-interval/
    ") gr.Interface(VideotoSegment, inputs=[spvvideo_file_input, spvsubtitle_file_input], outputs=spvdownload_output) gr.TextArea("Placeholder for ffmpeg command generator and ffmpeg-python code to split video") gr.Text("Text to Closed Class + Adjectives + Punctuation or Noun Verb + Punctuation ") with gr.Tab("Prepocessed Subtitles Practice"): gr.HTML("Custom SD script to create image for for each noun/ verb/ etc. - ") with gr.Row(): with gr.Column(): gr.HTML("Subtitle and Image Display") gr.HTML("Upload a zip file containing preprocessed subtitles and images.") with gr.Column(): ppssubtitleinput = gr.File(label="Upload Zip File") ppssubtitlebtn = gr.Button() with gr.Row(): with gr.Column(scale=1): ppssubtitletextout = gr.Textbox(label="Subtitle Output") with gr.Column(scale=2): ppssubtitleimages = gr.Gallery(label="Images")#.style(grid=[2], height="auto") ppssubtitlebtn.click(display_subtitles_from_zip, inputs=[ppssubtitleinput], outputs=[ppssubtitletextout , ppssubtitleimages]) with gr.Tab("Speed through Imagery"): with gr.Tab("Blended Images"): gr.HTML(" -- Lingua Link (Simple GPT for assistinng image creation) --
    Use with placeholder generator tab below
    Best for this is 2 nouns as one phrase i.e. nouns as adjectives and then you can a verb (1000 of those will take you far)") gr.HTML('Memorisation by string comparison idea

    Result of prompt chain starting with: Lets say I have the strings "red" and "ppalgan" how can I guess the second from the first from just spelling (eg. similar words and distance in the alphabet, ...), how can I use python to do this i.e. output of no matching letters, closest letter to r, then e, then d, a dictionary of letters that look similar eg. d and p, l and I a and d etc.') gr.Interface(fn=letterbased_guess_word, inputs=["text", "text"], outputs="text", description="letter based guess suggestions (one word to one word is the designed use case)") with gr.Accordion("More Details - conversation example", open=False): gr.Gallery(show_label=True, value=["adult-child-seong-in-namseong-DALL·E 2024-01-17.png", "adult child seong-in namseong DALL·E 2024-01-17 00.33.56.png", "adult (ɔpanyin) child (mmɔfra) DALL·E 2024-01-17 01.08.59.png", "adult (ɔpanyin) child (mmɔfra) DALL·E 2024-01-17 00.59.41.png"], label="Lingua Link Output - Mixed Spelling through Images") gr.HTML("""

    Adult Child is Seong-in Namseong

    How do we visualize this in one image?

    GPT's Concept

    To visualize "adult child" translated to "seong-in namseong" in Korean, we can create an image that creatively incorporates elements representing both an adult and a child. Here's a concept:

    • Scene: A park setting with a clear distinction between two halves.
    • Adult Side: One half shows an adult man in a business suit, holding a briefcase, standing near a bench with a newspaper and a cup of coffee.
    • Child Side: The other half shows a young boy, dressed in playful, colorful clothes, holding a toy airplane, standing near a sandbox with a bucket and spade.
    • Transition Element: A tree in the middle, with its leaves transitioning from green (adult side) to vibrant colors (child side), symbolizing the growth and change from childhood to adulthood.

    This image will represent the concept of an "adult child" or "seong-in namseong" by juxtaposing the characteristics of both stages of life.

    User's Inquiry

    Thats but where are the near spelled words?

    GPT's Revised Concept

    To incorporate words that are spelled similarly to "seong-in namseong," I will first find words in English that are close in spelling to the Korean phrase. Here are three words that somewhat resemble "seong-in namseong" in spelling:

    1. Singing - Resembles 'seong-in' in the sound and somewhat in spelling.
    2. Seasoning - Shares some similarity in spelling and phonetics with 'seong-in namseong'.
    3. Song - Similar to 'seong' in 'seong-in'.

    Now, let's integrate these words into the image concept:

    • Singing: The adult can be depicted as softly singing or humming a tune, perhaps with a subtle musical note symbol floating in the air.
    • Seasoning: The child could be playfully pretending to cook in the sandbox, with toy seasoning bottles.
    • Song: There could be a book or a sheet of music with a song's title visible, lying on the bench beside the adult.

    This revised concept includes elements related to the words "singing," "seasoning," and "song," which are visually connected to the original phrase "seong-in namseong."

    """) gr.Interface(fn=lingualinkassist, inputs=["text","text"], outputs="text", description="Lingua Link Prompt Assistance (Simple Prompts)") with gr.Tab("Filter Text for prompt items"): gr.HTML("Categories for Image Creation
    1. Extract only nouns
    2. Extract Acronyms
    3. Convert verbs to Careers
    Dall-E 3 best for multi concept images - every thing else = one picture at a time
    Ask the llm to create a prompt from the nouns extracted or to create english words ot sentences from the acronyms") gr.Interface(fn=onlyplurals, inputs=["text"], outputs=["text"], description="Only plurals = optimal concepts to learn first as LT work = repitition") gr.Interface(fn=create_acronym_map, inputs="textbox", outputs="textbox", description="Acronyms") gr.Interface(fn=keep_nouns, inputs="textbox", outputs="textbox", description="Nouns only") with gr.Tab("Placeholder Generation"): gr.HTML("Placeholder for every image of each sentence - Good for ChatGPT + Dall-E (First 16 Characters is part of the filename if you get error)") with gr.Row(): with gr.Column(scale=4): imageplaceholderinput = gr.TextArea(placeholder="Enter Text and Get a line by line (stand in for sentences for now) placeholder for image associated with the text") with gr.Column(scale=1): imageplaceholderdownload = gr.File() imageplaceholderbtn = gr.Button("Create the image placeholder") with gr.Row(): with gr.Column(scale=3): imageplaceholderoutput = gr.HTML("Preview will load here") with gr.Column(scale=2): imageplaceholdertextoutput = gr.Code("The code for the HTML created will come here") imageplaceholderbtn.click(fn=imagebasedreading, inputs=[imageplaceholderinput], outputs=[imageplaceholderdownload, imageplaceholderoutput, imageplaceholdertextoutput]) gr.Label("Word level Placeholder Generation") gr.Interface(fn=lambda sentence: ". ".join(sentence.split()), inputs=["text"], outputs=["text"], description="Use full stops before input below to make a world level version") gr.HTML("Placeholder for every image of each word - Good for ChatGPT + Dall-E (First 16 Characters is part of the filename if you get error)") with gr.Row(): with gr.Column(scale=4): imageplaceholderinputwordlevel = gr.TextArea(placeholder="Enter Text and Get a word by word placeholder for image associated with the text") with gr.Column(scale=1): imageplaceholderdownloadwordlevel = gr.File() imageplaceholderbtnwordlevel = gr.Button("Create the image placeholder") with gr.Row(): with gr.Column(scale=3): imageplaceholderoutputwordlevel = gr.HTML("Preview will load here") with gr.Column(scale=2): imageplaceholdertextoutputwordlevel = gr.Code("The code for the HTML created will come here") imageplaceholderbtnwordlevel.click(fn=imagebasedreadingwordlevel, inputs=[imageplaceholderinputwordlevel], outputs=[imageplaceholderdownloadwordlevel, imageplaceholderoutputwordlevel, imageplaceholdertextoutputwordlevel]) with gr.Tab("Kinesthetic / Mime Translation"): gr.HTML("placeholder for prompt generator and tests for llama-cpp with slm OR even opencv + a face open pose comparison to viseme face open pose structure") gr.HTML("Keep nouns and verbs -- turn every noun into a verb -- turn every verb into a pose") gr.HTML("""Viseme Test with video recording screenshots judged LMM

    # https://melindaozel.com/viseme-cheat-sheet/

    # https://developer.oculus.com/documentation/unity/audio-ovrlipsync-viseme-reference/

    # https://docs.aws.amazon.com/polly/latest/dg/viseme.html

    # https://docs.aws.amazon.com/polly/latest/dg/speechmarkexamples.html

    # https://docs.aws.amazon.com/polly/latest/dg/ref-phoneme-tables-shell.html

    # https://docs.aws.amazon.com/polly/latest/dg/ph-table-english-za.html

    # https://docs.aws.amazon.com/polly/latest/dg/ph-table-korean.html""") with gr.Tab("Incomplete Old Ideas"): gr.HTML("FINAL VERSION = Image placeholder + Merged Images + Side by Side Audio + UNWFWO Reader script + Spotify/Youtube integration in one interface
    True mastery is from the relations between each item aka how every word relates to each other - Repitition in the form combinatorics - llm turns these into full sentences / ideas ") gr.HTML("Focus = Thinking = Audio = Repitition = This space is just ideas for optimising the audio content. - Audio of side by side version -- listen till you can say the foreign before the audio plays it (Knowledge version is Glossary as vocab you must mastering before reading)") with gr.Tab("Multi Output and other ideas"): with gr.Row(): with gr.Column(): gr.HTML("Test using gradio space/interfaces through the api as function calls for gpt3.5 and 4") gr.HTML("Roblox as test for ability to describe? - -- Roblox Assistant -- |
    ") gr.HTML("State Management and Education
    Education = Learning things you didnt know yesterday and not forgetting more than you learn

    What you didnt know forms =
    Glossary
    Lists
    Formulas
    graphs
    Procedures

    for each you will need a seperate way to track the progress but amount of times + recency = approximate state ") with gr.Column(): gr.HTML("Start at Unkown Tracker if unseure
    UNNWFWO = Unknown Native Word Foreign Word Order i.e. during active listening practice you only need the words you dont know

    General Ideas in this space - Speed of Learning = Avoid Things you know like the plague -- How to track what you know -- Counter is easiest and How you feel is the hardest (The more you know, the more confusion on what you dont know as you probably werent keeping track)

    Visulisation of long text - Bottom of this page
    Wordlist - 1 new word at a time per minute in the space to the left
    Youtube Video Watching - Subtitles Tab
    Reading - Unknown Tracker Tabs
    Longer Text Memorising - Acronym Map Creation Tab and Transition Tab
    Brainstorming - Reading Assistant
    Random Exposure
    ") gr.Interface(fn=MultiOutputInterface, inputs=TestSplitandUpdateinput, outputs=["button", "text", "text", "text", "text", "text", "text", "text", "text", "text"]) with gr.Tab("Order based Forcing content into time (Time is the bottleneck)"): gr.Label("Inspect the Transition Tab last item in left most column - RandomiseTextbyType - Incomplete, but this plus timer will work well achieve what this space aims to achieve - LLMs would choose the next set of words based on the last batch and its knowledge of your vocab level or even your current location (using phone as sensors) and can make image/audio prompts to make more engaging") gr.Label("Placeholder for take in list and return 10 items in correct order for 20 seconds and 20 seconds to assign order to each word using numbers input - generator with blocks 20 seconds to understand what was wrong and move on") gr.Label("Placeholder for long text version as well - Order of the sentence or sentence spans (spacy) is what is what most important in long text - you cant organise you dont know") #with gr.Tab("Gradio Client Tests"): # gr.HTML("How to return componets here in gradio (as each client interface needs different inputs) like in react") with gr.Tab("Current Ideas to edit old sections"): gr.HTML("The core themes = scheduling (randomisation and calendar marking), speed practice, visualisation, and audio, repitition, compression and finally Tracking and only learning the unknown") gr.HTML("Parts that are already done - Repition and scheduling (randomisation) on the sidebar, compresion using the acronym tab, Audio in the beginning tab, unknown partially in HTML creator") gr.HTML("Parts that are not done - Visualisation (of acronyms / duo word sets / nouns and verbs) - The image placeholder creator script, Tracking (private = database, public = textfile export), calendar based scheduling aka alert based ") gr.HTML("React Version of the app can combine all of these use cases into one component - so far tracking, placeholder and partially scheduling have been done") gr.Label('True speed simultaneous - which is a boolean state = practice at simulataneous to get simultaneous |||| Another way to be fast is to practice simultaneously with the varios SOVs i.e. when you read a noun the verb must appear immediately and vice versa |||| Simultaneous Spelling is the other way to practice |||| The main goal of all reading is that next time you read you take less time this time: |||| Spped = ability to anticipate the next word |||| Anticipation of a sentence = POV |||| ') with gr.Accordion("Random Ideas"): gr.HTML("
    (Part to be formatted as System prompt for model used as the help admin for the app) Objective - Learn vocab from video/music and have record of how far you got using as overengineered solution (to keep upto date with SOTA AI models and use cases)
    Current Workflow = One Youtube video as focus for a week or until learned (i.e. instant recognition recall of vocab in random order exposure)
    Timeline Brainstorm = Know Nothing (Just need Exposure - Random 10% suggesed as starting point) --- Know a little (Remove known) --- Know half (UNNWFWO)
    ") gr.HTML("""

    Spaces Test - Still Undercontruction --> Next Milestone is Turning this interface handsfree | Knowledge is a Language but productive knowledge is find replace as well | LingQ is good option for per word state management

    Arrows app json creator for easy knowledge graphing and spacy POS graph? --> Questions? -->

    ChatGPT Turns Learning into a read only what you dont know ask only what you dont know feedback loop --> All you have to do is keep track of what prompts you have asked in the past

    """) gr.HTML("

    Target 0: Mnemonics as title of images --> Comprehensible input
    Target 1: Dual audio at word Level while using repitition to train random recall --> Word level Time
    Target 2: Video --> Split by sentence --> each word repeated (60) + each phrase (10) + each sentence (10) --> TTS file for practice --> State Management/Known word Tracker
    -----------------------
    The trick is minimum one minute of focus on a new word --> Listening is hard because there are new word within seconds and you need repeated focus on each to learn

    Audio = best long form attention mechanism AS it is ANTICIPATION (Awareness of something before it happens like knowing song Lyrics) FOCUSED - Attention (Focused Repitition) + Exposure (Random Repitition)

    Listening is hard due to different word order and word combinations (collocations more important than single words)

    ") gr.HTML("Predictable to identify the parts of picture being described --> The description moves in one direction from one side of the image to the other side is easiest
    ") gr.HTML("Image = instant comprehension like Stable Diffusion --> Audiovisual experience is the most optimal reading experience
    Manga with summary descriptions for the chapters = Most aligned visual to audio experience") with gr.Tab("Simultanoues Practice Zone"): gr.Label("Audio based space where you must look at the corresponding text for the audio thats playing as simultaneous practice") gr.DataFrame(None, headers=["text", "audio"], label="Add text pairs to practice", interactive=True) with gr.Tab("Gradio Client Tests and Ideas"): gr.Interface(fn=TestGradioClientQwen270b, inputs="text", outputs="text", description="Single response test of gradio client - Qwen/Qwen2-72B-Instruct, Use for testing like using a space and duplicate for heavy testing") lliface.queue().launch() #share=True) #docker #(inbrowser="true") #colab #httpcore and googletrans seem to be the cause all my bugs ---> These are problems to watch #not using the exact package versions as your local environment will lead to problems in the future when backwards compatibility is not reintroduced # current exact packages # gradio==4.13 # httpx==0.13.3 # googletrans==3.1.0a0