Spaces:
Sleeping
Sleeping
| # suppress warnings | |
| import warnings | |
| warnings.filterwarnings("ignore") | |
| # import libraries | |
| import argparse | |
| from together import Together | |
| import textwrap | |
| import os | |
| from datetime import datetime | |
| import gradio as gr | |
| # Parse command line arguments | |
| parser = argparse.ArgumentParser(description="AI Study Tool") | |
| parser.add_argument( | |
| "--together_api_key", | |
| "-k", | |
| default="9806a2601560024637df1e4acd804862faa67e08637db6598d920b64eebba43e", | |
| help="Together AI API key", | |
| ) | |
| args = parser.parse_args() | |
| # Initialize client with API key | |
| client = Together(api_key=args.together_api_key) | |
| # Add the cats content as a constant string | |
| CATS_CONTENT = """The cat (Felis catus), also referred to as the domestic cat or house cat, is a small domesticated carnivorous mammal. It is the only domesticated species of the family Felidae. Advances in archaeology and genetics have shown that the domestication of the cat occurred in the Near East around 7500 BC. It is commonly kept as a pet and working cat, but also ranges freely as a feral cat avoiding human contact. It is valued by humans for companionship and its ability to kill vermin. Its retractable claws are adapted to killing small prey species such as mice and rats. It has a strong, flexible body, quick reflexes, and sharp teeth, and its night vision and sense of smell are well developed. It is a social species, but a solitary hunter and a crepuscular predator. | |
| Cat intelligence is evident in their ability to adapt, learn through observation, and solve problems. Research has shown they possess strong memories, exhibit neuroplasticity, and display cognitive skills comparable to those of a young child. Cat communication includes meowing, purring, trilling, hissing, growling, grunting, and body language. It can hear sounds too faint or too high in frequency for human ears, such as those made by small mammals. It secretes and perceives pheromones. | |
| Female domestic cats can have kittens from spring to late autumn in temperate zones and throughout the year in equatorial regions, with litter sizes often ranging from two to five kittens. Domestic cats are bred and shown at cat fancy events as registered pedigreed cats. Population control includes spaying and neutering, but pet abandonment has exploded the global feral cat population, which has driven the extinction of bird, mammal, and reptile species. | |
| Domestic cats are found across the globe, though their popularity as pets varies by region. Out of the estimated 600 million cats worldwide, 400 million reside in Asia, including 58 million pet cats in China. The United States leads in cat ownership with 73.8 million cats. In the United Kingdom, approximately 10.9 million domestic cats are kept as pets. | |
| Etymology and naming | |
| The origin of the English word cat, Old English catt, is thought to be the Late Latin word cattus, which was first used at the beginning of the 6th century.[4] The Late Latin word may be derived from an unidentified African language.[5] The Nubian word kaddîska (wildcat) and Nobiin kadīs are possible sources or cognates.[6] | |
| The forms might also have derived from an ancient Germanic word that was absorbed into Latin and then into Greek, Syriac, and Arabic.[7] The word may be derived from Germanic and Northern European languages, and ultimately be borrowed from Uralic, cf. Northern Sámi gáđfi, female stoat, and Hungarian hölgy, lady, female stoat; from Proto-Uralic *käďwä, female (of a furred animal).[8] | |
| The English puss, extended as pussy and pussycat, is attested from the 16th century and may have been introduced from Dutch poes or from Low German puuskatte, related to Swedish kattepus, or Norwegian pus, pusekatt. Similar forms exist in Lithuanian puižė and Irish puisín or puiscín. The etymology is unknown, but it may be an onomatopoeia from using a sound to attract a cat.[9][10] | |
| A male cat is called a tom or tomcat[11] (or a gib,[12] if neutered). A female is called a queen.[13] Some sources write that queen refers solely to unspayed cats that are in an estrous cycle.[14] (or sometimes a molly,[15] if spayed). A juvenile cat is referred to as a kitten, a term interchangeable with the now-obsolete word catling in Early Modern English.[16] A group of cats can be referred to as a clowder, a glaring,[17] or a colony.[18] | |
| Taxonomy | |
| The scientific name Felis catus was proposed by Carl Linnaeus in 1758 for a domestic cat.[1][2] Felis catus domesticus was proposed by Johann Christian Polycarp Erxleben in 1777.[3] Felis daemon proposed by Konstantin Satunin in 1904 was a black cat from the Transcaucasus, later identified as a domestic cat.[19][20] | |
| In 2003, the International Commission on Zoological Nomenclature ruled that the domestic cat is a distinct species, namely Felis catus.[21][22] In 2007, the modern domesticated subspecies F. silvestris catus sampled worldwide was considered to have probably descended from the African wildcat (F. lybica), following results of phylogenetic research.[23][24][a] In 2017, the IUCN Cat Classification Taskforce followed the recommendation of the ICZN in regarding the domestic cat as a distinct species, Felis catus.[25]""" | |
| ## FUNCTION 1: This Allows Us to Prompt the AI MODEL | |
| # ------------------------------------------------- | |
| def prompt_llm(prompt, with_linebreak=False): | |
| # This function allows us to prompt an LLM via the Together API | |
| # model | |
| model = "meta-llama/Meta-Llama-3-8B-Instruct-Lite" | |
| # Make the API call | |
| response = client.chat.completions.create( | |
| model=model, | |
| messages=[{"role": "user", "content": prompt}], | |
| ) | |
| output = response.choices[0].message.content | |
| if with_linebreak: | |
| # Wrap the output | |
| wrapped_output = textwrap.fill(output, width=50) | |
| return wrapped_output | |
| else: | |
| return output | |
| ## FUNCTION 2: Load text file content | |
| # ------------------------------------------------- | |
| def load_file(filepath): | |
| """Load content from a text file""" | |
| try: | |
| with open(filepath, "r", encoding="utf-8") as file: | |
| return file.read() | |
| except FileNotFoundError: | |
| print(f"Error: File {filepath} not found.") | |
| return None | |
| except Exception as e: | |
| print(f"Error reading file: {e}") | |
| return None | |
| ## FUNCTION 3: Generate bite-sized concept summaries | |
| # ------------------------------------------------- | |
| def summarize_concepts(text_content): | |
| """Generate bite-sized 2-sentence concepts from text content""" | |
| prompt = f""" | |
| Please analyze the following text and break it down into bite-sized learning concepts. | |
| For each concept, provide exactly 2 sentences that capture the key idea in a clear, | |
| easy-to-understand way suitable for studying. | |
| Format each concept as: | |
| Concept X: [2 sentences explaining the concept] | |
| Text to analyze: | |
| {text_content} | |
| """ | |
| return prompt_llm(prompt) | |
| ## FUNCTION 4: Save results to timestamped file | |
| # ------------------------------------------------- | |
| def save_results(content, output_dir="results"): | |
| """Save content to a timestamped file in the results directory""" | |
| # Create results directory if it doesn't exist | |
| os.makedirs(output_dir, exist_ok=True) | |
| # Generate timestamp | |
| timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") | |
| filename = f"{timestamp}.txt" | |
| filepath = os.path.join(output_dir, filename) | |
| # Save content | |
| try: | |
| with open(filepath, "w", encoding="utf-8") as file: | |
| file.write(content) | |
| print(f"Results saved to: {filepath}") | |
| return filepath | |
| except Exception as e: | |
| print(f"Error saving file: {e}") | |
| return None | |
| ## FUNCTION 5: Create Gradio Interface | |
| # ------------------------------------------------- | |
| def create_gradio_interface(): | |
| """Create a Gradio interface for the study tool""" | |
| def process_file_and_generate_content(): | |
| """Process the cats content and generate study content""" | |
| try: | |
| # Use the hardcoded content instead of loading from file | |
| content = CATS_CONTENT | |
| # Generate summaries | |
| summaries = summarize_concepts(content) | |
| # Parse summaries into individual concepts - improved parsing for **Concept X:** format | |
| concepts = [] | |
| # Split by **Concept and filter out empty parts | |
| parts = summaries.split("**Concept") | |
| for i, part in enumerate(parts): | |
| if i == 0: # Skip the intro text before first concept | |
| continue | |
| # Clean up the part and add back "Concept" prefix | |
| concept_text = "Concept" + part.strip() | |
| # Remove the closing ** if present | |
| if concept_text.endswith("**"): | |
| concept_text = concept_text[:-2].strip() | |
| # Remove any ** formatting within the text | |
| concept_text = concept_text.replace("**", "") | |
| if concept_text: | |
| concepts.append(concept_text) | |
| # Save results | |
| save_results(f"BITE-SIZED CONCEPT SUMMARIES:\n{summaries}") | |
| # Return first concept for immediate display | |
| first_concept = concepts[0] if concepts else "No concepts generated." | |
| return ( | |
| f"Content processed successfully! Found {len(concepts)} concepts. Navigate through them below.", | |
| summaries, | |
| concepts, | |
| 0, # current concept index | |
| first_concept, # display first concept immediately | |
| ) | |
| except Exception as e: | |
| return f"Error processing content: {str(e)}", "", [], 0, "Error occurred." | |
| def navigate_concept(concepts, current_idx, direction): | |
| """Navigate through concepts (previous/next)""" | |
| if not concepts: | |
| return "No concepts available.", 0 | |
| if direction == "next": | |
| new_idx = min(current_idx + 1, len(concepts) - 1) | |
| else: # previous | |
| new_idx = max(current_idx - 1, 0) | |
| concept_text = ( | |
| concepts[new_idx] if new_idx < len(concepts) else "No concept available." | |
| ) | |
| return concept_text, new_idx | |
| # Create Gradio interface | |
| with gr.Blocks(title="AI Study Tool", theme=gr.themes.Soft()) as interface: | |
| gr.Markdown("# 📚 AI Study Tool") | |
| gr.Markdown("Generate bite-sized concepts from cat information for studying!") | |
| # Process button section | |
| with gr.Row(): | |
| process_btn = gr.Button("Process Cat Content", variant="primary") | |
| # Status and results | |
| status_output = gr.Textbox(label="Status", interactive=False) | |
| # Hidden state variables | |
| full_summaries = gr.State("") | |
| concepts_list = gr.State([]) | |
| current_concept_idx = gr.State(0) | |
| # Concept navigation section | |
| with gr.Row(): | |
| gr.Markdown("## 🧠 Study Concepts") | |
| with gr.Row(): | |
| prev_btn = gr.Button("← Previous Concept") | |
| concept_counter = gr.Textbox( | |
| label="Concept Position", interactive=False, value="0 / 0" | |
| ) | |
| next_btn = gr.Button("Next Concept →") | |
| concept_display = gr.Textbox( | |
| label="Current Concept", | |
| lines=4, | |
| interactive=False, | |
| placeholder="Process a file to see concepts here...", | |
| ) | |
| # Event handlers | |
| process_btn.click( | |
| fn=process_file_and_generate_content, | |
| inputs=[], | |
| outputs=[ | |
| status_output, | |
| full_summaries, | |
| concepts_list, | |
| current_concept_idx, | |
| concept_display, | |
| ], | |
| ).then( | |
| fn=lambda concepts, idx: ( | |
| f"{idx + 1} / {len(concepts)}" if concepts else "0 / 0" | |
| ), | |
| inputs=[concepts_list, current_concept_idx], | |
| outputs=[concept_counter], | |
| ) | |
| prev_btn.click( | |
| fn=lambda concepts, idx: navigate_concept(concepts, idx, "previous"), | |
| inputs=[concepts_list, current_concept_idx], | |
| outputs=[concept_display, current_concept_idx], | |
| ).then( | |
| fn=lambda concepts, idx: ( | |
| f"{idx + 1} / {len(concepts)}" if concepts else "0 / 0" | |
| ), | |
| inputs=[concepts_list, current_concept_idx], | |
| outputs=[concept_counter], | |
| ) | |
| next_btn.click( | |
| fn=lambda concepts, idx: navigate_concept(concepts, idx, "next"), | |
| inputs=[concepts_list, current_concept_idx], | |
| outputs=[concept_display, current_concept_idx], | |
| ).then( | |
| fn=lambda concepts, idx: ( | |
| f"{idx + 1} / {len(concepts)}" if concepts else "0 / 0" | |
| ), | |
| inputs=[concepts_list, current_concept_idx], | |
| outputs=[concept_counter], | |
| ) | |
| return interface | |
| if __name__ == "__main__": | |
| # Launch Gradio interface | |
| interface = create_gradio_interface() | |
| interface.launch() | |