Upload app.py

app.py

@@ -0,0 +1,1343 @@
+import streamlit as st
+import requests
+import os
+import re
+from PIL import Image
+import tempfile
+
+# List of allowed file extensions for uploads
+ALLOWED_EXTENSIONS = {'png', 'jpg', 'jpeg', 'gif'}
+
+def allowed_file(filename):
+    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
+
+def main():
+    st.set_page_config(page_title="Species Information Finder", layout="wide")
+    
+    st.title("Species Information Finder")
+    st.write("Discover information about any species by name or by uploading an image.")
+    
+    # Create tabs for different functionality
+    tab1, tab2 = st.tabs(["Search by Name", "Search by Image"])
+    
+    with tab1:
+        st.header("Search by Species Name")
+        species_name = st.text_input("Enter a species name (common or scientific):")
+        
+        if st.button("Search"):
+            if not species_name:
+                st.error("Please enter a species name")
+            else:
+                with st.spinner("Searching for species information..."):
+                    # Get species info from Wikispecies API
+                    species_data = get_species_info(species_name)
+                    
+                    # Get images from Wikimedia Commons API
+                    images = get_species_images(species_name)
+                    
+                    display_results(species_data, images)
+    
+    with tab2:
+        st.header("Search by Image Upload")
+        uploaded_file = st.file_uploader("Upload an image of a species", type=ALLOWED_EXTENSIONS)
+        
+        if uploaded_file is not None:
+            if allowed_file(uploaded_file.name):
+                # Display the uploaded image
+                image = Image.open(uploaded_file)
+                st.image(image, caption="Uploaded Image", use_column_width=True)
+                
+                if st.button("Identify Species"):
+                    with st.spinner("Identifying species from image..."):
+                        # In a real app, you would call an image recognition API here
+                        # For demo purposes, we'll use our mock function
+                        species_name = get_mock_species_from_filename(uploaded_file.name)
+                        
+                        # Get species info from Wikispecies API
+                        species_data = get_species_info(species_name)
+                        
+                        # Get images from Wikimedia Commons API
+                        images = get_species_images(species_name)
+                        
+                        display_results(species_data, images)
+            else:
+                st.error("File type not allowed. Please upload an image file (PNG, JPG, JPEG, GIF).")
+
+def display_results(species_data, images):
+    """Display the results in a formatted way."""
+    if "error" in species_data:
+        st.error(species_data["error"])
+        return
+    
+    st.success(f"Found information for: {species_data['title']}")
+    
+    # Create columns for layout
+    col1, col2 = st.columns([1, 2])
+    
+    with col1:
+        # Display classification information
+        st.subheader("Classification")
+        classification = species_data.get("classification", {})
+        for rank, value in classification.items():
+            if value != "Unknown":
+                st.write(f"{rank.capitalize()}:** {value}")
+        
+        # Display habitat information
+        if species_data.get("habitat", "Unknown") != "Unknown":
+            st.subheader("Habitat")
+            st.write(species_data["habitat"])
+    
+    with col2:
+        # Display description
+        st.subheader("Description")
+        st.write(species_data.get("description", "No description available."))
+        
+        # Display fun facts if available
+        if species_data.get("fun_facts"):
+            st.subheader("Interesting Facts")
+            for i, fact in enumerate(species_data["fun_facts"], 1):
+                st.write(f"{i}. {fact}")
+    
+    # Display images if available
+    if images:
+        st.subheader("Related Images")
+        
+        # Display up to 4 images in a grid
+        cols = st.columns(min(4, len(images)))
+        for idx, img in enumerate(images[:4]):
+            with cols[idx]:
+                if "thumb_url" in img:
+                    st.image(img["thumb_url"], caption=img.get("description", ""), use_column_width=True)
+                else:
+                    st.image(img["url"], caption=img.get("description", ""), use_column_width=True)
+                st.caption(f"Credit: {img.get('author', 'Unknown')} | License: {img.get('license', 'Unknown')}")
+    else:
+        st.warning("No images found for this species.")
+
+# All the existing functions from your Flask app can remain exactly the same
+# (get_species_info, get_wikispecies_data, get_wikipedia_data, etc.)
+# I'll include them below for completeness, but they don't need to change
+
+def get_species_info(species_name):
+    """
+    Get species information from both Wikispecies and Wikipedia APIs
+    with improved extraction and fallback strategies for better results.
+    """
+    # Create the base species info structure
+    species_info = {
+        "title": species_name,  # Default to the search query
+        "description": "No description available.",
+        "categories": [],
+        "links": [],
+        "last_modified": "Unknown",
+        "classification": {
+            "kingdom": "Unknown", 
+            "phylum": "Unknown", 
+            "class": "Unknown", 
+            "order": "Unknown", 
+            "family": "Unknown", 
+            "genus": "Unknown", 
+            "species": "Unknown"
+        },
+        "habitat": "Unknown",
+        "fun_facts": [],
+        "data_sources": []  # Track where we got data from
+    }
+    
+    # Try to get data from Wikispecies first
+    wikispecies_info = get_wikispecies_data(species_name)
+    
+    # If we got a valid response, update our species_info
+    if not wikispecies_info.get("error"):
+        species_info.update(wikispecies_info)
+        species_info["data_sources"].append("Wikispecies")
+    
+    # Now try to get complementary data from Wikipedia
+    wikipedia_info = get_wikipedia_data(species_name)
+    
+    # If Wikipedia returned valid data, supplement our existing info
+    if not wikipedia_info.get("error"):
+        # Use Wikipedia description if Wikispecies didn't have one
+        if species_info["description"] == "No description available." or len(species_info["description"]) < 50:
+            species_info["description"] = wikipedia_info.get("description", species_info["description"])
+        
+        # Always prefer Wikipedia habitat info as it's likely more detailed
+        species_info["habitat"] = wikipedia_info.get("habitat", species_info["habitat"])
+        
+        # Merge classification info from Wikipedia, preferring Wikipedia data
+        if "classification" in wikipedia_info:
+            for rank, value in wikipedia_info["classification"].items():
+                if value != "Unknown":
+                    species_info["classification"][rank] = value
+        
+        # Add Wikipedia fun facts to our collection, avoiding duplicates
+        if wikipedia_info.get("fun_facts"):
+            existing_facts = species_info.get("fun_facts", [])
+            for fact in wikipedia_info["fun_facts"]:
+                if not any(similarity_score(fact, existing) > 0.7 for existing in existing_facts):
+                    existing_facts.append(fact)
+            species_info["fun_facts"] = existing_facts[:4]  # Limit to 4 facts
+        
+        species_info["data_sources"].append("Wikipedia")
+    
+    # If we didn't get any data from either source, return an error
+    if not species_info["data_sources"]:
+        species_info["error"] = "Species information not found in either Wikispecies or Wikipedia."
+    
+    return species_info
+
+def get_wikispecies_data(species_name):
+    """
+    Get species information from Wikispecies API
+    """
+    # Wikispecies API endpoint
+    url = "https://species.wikimedia.org/w/api.php"
+    
+    # Parameters for the API request - get more info to work with
+    params = {
+        "action": "query",
+        "format": "json",
+        "titles": species_name,
+        "prop": "extracts|categories|info|links",
+        "exintro": True,  # Get only the intro section
+        "explaintext": True,  # Get plain text, not HTML
+        "cllimit": 50,  # Get more categories
+        "pllimit": 50,  # Get more links
+    }
+    
+    try:
+        response = requests.get(url, params=params)
+        data = response.json()
+        
+        # Extract page data
+        pages = data.get("query", {}).get("pages", {})
+        
+        if not pages:
+            return {"error": "No data found in Wikispecies"}
+        
+        # Get the first page (there should only be one)
+        page_id = next(iter(pages))
+        page = pages[page_id]
+        
+        # Default information structure with placeholders
+        species_info = {
+            "title": species_name,  # Default to the search query
+            "description": "No description available.",
+            "categories": [],
+            "links": [],
+            "last_modified": "Unknown",
+            "classification": {
+                "kingdom": "Unknown", 
+                "phylum": "Unknown", 
+                "class": "Unknown", 
+                "order": "Unknown", 
+                "family": "Unknown", 
+                "genus": "Unknown", 
+                "species": "Unknown"
+            },
+            "habitat": "Unknown",
+            "fun_facts": []
+        }
+        
+        # Check if the page exists
+        if int(page_id) < 0:
+            species_info["error"] = "Species not found in Wikispecies. Try a different spelling or check for the scientific name."
+            return species_info
+        
+        # Extract the relevant information
+        species_info["title"] = page.get("title", species_name)
+        species_info["description"] = page.get("extract", "No description available.")
+        
+        # Get all categories
+        if "categories" in page:
+            species_info["categories"] = [cat.get("title") for cat in page.get("categories", [])]
+        
+        # Get all links (can be useful for finding related info)
+        if "links" in page:
+            species_info["links"] = [link.get("title") for link in page.get("links", [])]
+            
+        species_info["last_modified"] = page.get("touched", "Unknown")
+        
+        # Clean up the description (remove unnecessary line breaks, etc.)
+        if species_info["description"]:
+            species_info["description"] = species_info["description"].replace("\n", " ").strip()
+            # Remove multiple spaces
+            import re
+            species_info["description"] = re.sub(r' +', ' ', species_info["description"])
+        
+        # Try different strategies to extract classification
+        # Strategy 1: Extract from categories
+        species_info["classification"] = extract_classification(species_info["categories"])
+        
+        # Strategy 2: Try to extract genus and species from the title if available
+        title = species_info.get("title", "")
+        title_parts = title.split()
+        
+        # If the title consists of two words, it might be a binomial name (genus + species)
+        if len(title_parts) == 2:
+            genus = title_parts[0]
+            species = title_parts[1]
+            
+            # Update classification with this information
+            classification = species_info.get("classification", {})
+            if classification.get("genus") == "Unknown":
+                classification["genus"] = genus
+            if classification.get("species") == "Unknown":
+                classification["species"] = species
+            species_info["classification"] = classification
+        
+        # Strategy 3: Look for classification information in links
+        if species_info.get("links"):
+            for link in species_info["links"]:
+                # Check if link might be a taxonomic rank
+                link_parts = link.split()
+                if len(link_parts) == 1:
+                    # Check common taxonomic suffixes for families, orders, etc.
+                    if link.endswith("idae"):  # Family suffix
+                        species_info["classification"]["family"] = link
+                    elif link.endswith("inae"):  # Subfamily suffix
+                        # Store subfamily info in a separate key
+                        species_info["classification"]["subfamily"] = link
+                    elif link.endswith("ales"):  # Order suffix for plants
+                        species_info["classification"]["order"] = link
+                    elif link.endswith("aceae"):  # Family suffix for plants
+                        species_info["classification"]["family"] = link
+        
+        # Extract habitat info 
+        species_info["habitat"] = extract_habitat(species_info["description"])
+        
+        # Extract fun facts
+        species_info["fun_facts"] = extract_fun_facts(species_info["description"])
+        
+        # If the description is too short or missing, try to create a basic description
+        if not species_info["description"] or len(species_info["description"]) < 20:
+            # Create a basic description from available information
+            classification = species_info["classification"]
+            parts = []
+            
+            if classification["genus"] != "Unknown" and classification["species"] != "Unknown":
+                parts.append(f"{species_info['title']} is a species in the genus {classification['genus']}.")
+            
+            if classification["family"] != "Unknown":
+                parts.append(f"It belongs to the family {classification['family']}.")
+                
+            if classification["order"] != "Unknown":
+                parts.append(f"It is classified under the order {classification['order']}.")
+                
+            if parts:
+                species_info["description"] = " ".join(parts)
+            else:
+                species_info["description"] = f"{species_info['title']} is a species documented in Wikispecies, the free species directory."
+        
+        return species_info
+    
+    except Exception as e:
+        error_msg = str(e)
+        return {
+            "error": f"Error retrieving species information from Wikispecies: {error_msg}",
+            "title": species_name,
+            "description": "No information available due to an error. Please try a different species name.",
+            "classification": {"kingdom": "Unknown", "phylum": "Unknown", "class": "Unknown", "order": "Unknown", "family": "Unknown", "genus": "Unknown", "species": "Unknown"},
+            "habitat": "Unknown",
+            "fun_facts": []
+        }
+
+def get_wikipedia_data(species_name):
+    """
+    Get species information from Wikipedia API, focusing on description,
+    habitat, and fun facts.
+    """
+    # Wikipedia API endpoint
+    url = "https://en.wikipedia.org/w/api.php"
+    
+    # First, try to search for the page to get the correct title
+    search_params = {
+        "action": "query",
+        "format": "json",
+        "list": "search",
+        "srsearch": species_name,
+        "srlimit": 1,  # Get just the best match
+    }
+    
+    try:
+        # Search for the page first to get the exact title
+        search_response = requests.get(url, params=search_params)
+        search_data = search_response.json()
+        
+        # Check if we found any search results
+        search_results = search_data.get("query", {}).get("search", [])
+        if not search_results:
+            return {"error": "No matching Wikipedia page found for this species."}
+        
+        # Get the page title from the search result
+        page_title = search_results[0].get("title")
+        
+        # Now get the full page content
+        content_params = {
+            "action": "query",
+            "format": "json",
+            "titles": page_title,
+            "prop": "extracts|categories|sections",
+            "exintro": False,  # Get the full content, not just the intro
+            "explaintext": True,  # Get plain text, not HTML
+            "cllimit": 50,  # Get more categories
+        }
+        
+        content_response = requests.get(url, params=content_params)
+        content_data = content_response.json()
+        
+        # Extract page data
+        pages = content_data.get("query", {}).get("pages", {})
+        
+        if not pages:
+            return {"error": "Failed to retrieve Wikipedia page content."}
+        
+        # Get the first page (there should only be one)
+        page_id = next(iter(pages))
+        page = pages[page_id]
+        
+        # Check if the page exists
+        if int(page_id) < 0:
+            return {"error": "Wikipedia page not found."}
+        
+        # Get basic information
+        species_info = {
+            "title": page.get("title", species_name),
+            "description": "",
+            "habitat": "Unknown",
+            "fun_facts": [],
+            "classification": {
+                "kingdom": "Unknown", 
+                "phylum": "Unknown", 
+                "class": "Unknown", 
+                "order": "Unknown", 
+                "family": "Unknown", 
+                "genus": "Unknown", 
+                "species": "Unknown"
+            }
+        }
+        
+        # Extract the content
+        full_text = page.get("extract", "")
+        
+        # Clean up the text
+        if full_text:
+            full_text = full_text.replace("\n\n", "||").replace("\n", " ").replace("||", "\n\n")
+            
+            # Get sections from the content
+            sections = full_text.split("\n\n")
+            
+            # The first section is usually a good description
+            if sections:
+                species_info["description"] = sections[0].strip()
+            
+            # Look for habitat information in the full text
+            habitat_section = extract_wikipedia_section(full_text, ["Habitat", "Distribution", "Range", "Ecology", "Environment"])
+            if habitat_section:
+                species_info["habitat"] = habitat_section
+            else:
+                # If no specific habitat section, use our habitat extraction on the full text
+                habitat = extract_habitat(full_text)
+                if habitat != "Unknown":
+                    species_info["habitat"] = habitat
+            
+            # Extract fun facts from various interesting sections
+            behavior_section = extract_wikipedia_section(full_text, ["Behavior", "Behaviour", "Life cycle", "Diet", "Feeding", "Reproduction", "Biology"])
+            if behavior_section:
+                facts = extract_fun_facts(behavior_section)
+                if facts:
+                    species_info["fun_facts"].extend(facts)
+            
+            # If we don't have enough facts, try conservation status or other sections
+            if len(species_info["fun_facts"]) < 2:
+                conservation_section = extract_wikipedia_section(full_text, ["Conservation", "Status", "Threats", "Population"])
+                if conservation_section:
+                    facts = extract_fun_facts(conservation_section)
+                    if facts:
+                        for fact in facts:
+                            if fact not in species_info["fun_facts"]:
+                                species_info["fun_facts"].append(fact)
+            
+            # If we still don't have enough facts, use our fun facts extraction on the full text
+            if len(species_info["fun_facts"]) < 2:
+                general_facts = extract_fun_facts(full_text)
+                if general_facts:
+                    for fact in general_facts:
+                        if fact not in species_info["fun_facts"]:
+                            species_info["fun_facts"].append(fact)
+            
+            # Limit to 4 facts
+            species_info["fun_facts"] = species_info["fun_facts"][:4]
+            
+            # Extract classification from Wikipedia content
+            wiki_classification = extract_wikipedia_classification(full_text, page.get("title", ""), search_data)
+            if wiki_classification:
+                species_info["classification"] = wiki_classification
+        
+        return species_info
+    
+    except Exception as e:
+        error_msg = str(e)
+        return {
+            "error": f"Error retrieving information from Wikipedia: {error_msg}",
+            "title": species_name,
+            "description": "No information available from Wikipedia due to an error.",
+            "habitat": "Unknown",
+            "fun_facts": []
+        }
+
+def extract_wikipedia_section(text, section_keywords):
+    """
+    Try to extract a specific section from Wikipedia text content.
+    Returns the first matching section or None if no match is found.
+    """
+    if not text:
+        return None
+    
+    # Try to find section headings in the text
+    section_pattern = r"==\s*([^=]+)\s*=="
+    sections = re.findall(section_pattern, text)
+    
+    # Check if any of our target sections exist
+    matching_sections = []
+    for keyword in section_keywords:
+        for section in sections:
+            if keyword.lower() in section.lower():
+                # Found a matching section, now extract its content
+                section_regex = re.escape(f"== {section} ==")
+                try:
+                    # Find where this section starts
+                    start_match = re.search(section_regex, text)
+                    if start_match:
+                        start_pos = start_match.end()
+                        
+                        # Find where the next section starts
+                        next_section = re.search(r"==\s*[^=]+\s*==", text[start_pos:])
+                        if next_section:
+                            end_pos = start_pos + next_section.start()
+                            section_text = text[start_pos:end_pos].strip()
+                        else:
+                            # This is the last section
+                            section_text = text[start_pos:].strip()
+                        
+                        matching_sections.append(section_text)
+                except Exception:
+                    # Skip this section if there's any error processing it
+                    continue
+    
+    # If we found any matching sections, join them (limit to 2 for conciseness)
+    if matching_sections:
+        return " ".join(matching_sections[:2])
+    
+    # Alternative approach: look for paragraphs containing the keywords
+    paragraphs = text.split("\n\n")
+    for keyword in section_keywords:
+        for paragraph in paragraphs:
+            if keyword.lower() in paragraph.lower():
+                return paragraph
+    
+    return None
+
+def get_species_images(species_name):
+    """
+    Get species images from Wikimedia Commons API with improved search
+    strategies for better results.
+    """
+    # Wikimedia Commons API endpoint
+    url = "https://commons.wikimedia.org/w/api.php"
+    
+    # Function to perform a search with given parameters
+    def search_images(search_term, limit=10):
+        # Parameters for the API request
+        params = {
+            "action": "query",
+            "format": "json",
+            "generator": "search",
+            "gsrnamespace": 6,  # File namespace
+            "gsrsearch": search_term,
+            "gsrlimit": limit,  # Limit results
+            "prop": "imageinfo",
+            "iiprop": "url|extmetadata",
+            "iiurlwidth": 800,  # Thumbnail width
+        }
+        
+        try:
+            response = requests.get(url, params=params)
+            data = response.json()
+            
+            # Extract image data
+            pages = data.get("query", {}).get("pages", {})
+            
+            if not pages:
+                return []
+            
+            images = []
+            for page_id, page in pages.items():
+                image_info = page.get("imageinfo", [{}])[0]
+                
+                # Extract metadata
+                metadata = image_info.get("extmetadata", {})
+                description = metadata.get("ImageDescription", {}).get("value", "No description")
+                author = metadata.get("Artist", {}).get("value", "Unknown")
+                license = metadata.get("License", {}).get("value", "Unknown")
+                
+                # Skip non-image files (like pdfs, audio, etc.)
+                title = page.get("title", "").lower()
+                if any(ext in title for ext in ['.pdf', '.svg', '.mp3', '.mp4', '.ogg', '.wav', '.webm']):
+                    continue
+                
+                image = {
+                    "title": page.get("title", "Unknown"),
+                    "url": image_info.get("url", ""),
+                    "thumb_url": image_info.get("thumburl", ""),
+                    "description": description,
+                    "author": author,
+                    "license": license,
+                }
+                
+                images.append(image)
+            
+            return images
+        
+        except Exception as e:
+            return [{"error": str(e)}]
+    
+    # STRATEGY 1: Try exact file name search first
+    images = search_images(f"file:{species_name}")
+    
+    # If no results, try a broader search
+    if not images:
+        # STRATEGY 2: Try removing the file: prefix for broader results
+        images = search_images(species_name)
+    
+    # If still no results or very few, try some variations
+    if len(images) < 3:
+        # Split the species name and try different combinations
+        name_parts = species_name.split()
+        
+        # STRATEGY 3: If it's a binomial name, try with just the genus or species part
+        if len(name_parts) == 2:
+            # Try with just the genus (first part)
+            genus_images = search_images(f"{name_parts[0]}")
+            
+            # Add unique images from genus search
+            existing_urls = [img.get("url") for img in images]
+            for img in genus_images:
+                if img.get("url") not in existing_urls:
+                    images.append(img)
+                    existing_urls.append(img.get("url"))
+                    
+                    # Stop if we now have enough images
+                    if len(images) >= 5:
+                        break
+    
+    # If we found at least some images, return them
+    if images:
+        return images
+    
+    # STRATEGY 4: Last resort - try a very general search
+    # This could be improved by using the taxonomy info
+    return search_images("species taxonomy nature")
+
+def extract_classification(categories):
+    """
+    Extract classification information from categories and additional WikiData
+    with improved pattern matching and detection.
+    """
+    # Initialize with default "Unknown" values
+    classification = {
+        "kingdom": "Unknown",
+        "phylum": "Unknown",
+        "class": "Unknown",
+        "order": "Unknown",
+        "family": "Unknown",
+        "genus": "Unknown",
+        "species": "Unknown",
+    }
+    
+    # Skip empty categories
+    if not categories:
+        return classification
+    
+    # Common taxonomy patterns in category names with more variations
+    taxonomy_patterns = {
+        "kingdom": ["kingdom:", "regnum:", "reino:", "regno:", "kingdom ", "regnum ", "reino ", "reino "],
+        "phylum": ["phylum:", "division:", "división:", "divisio:", "phylum ", "division ", "división ", "divisio "],
+        "class": ["class:", "clase:", "classis:", "class ", "clase ", "classis "],
+        "order": ["order:", "orden:", "ordo:", "order ", "orden ", "ordo "],
+        "family": ["family:", "familia:", "family ", "familia "],
+        "genus": ["genus:", "género:", "genero:", "genus ", "género ", "genero "],
+        "species": ["species:", "especie:", "specie:", "species ", "especie ", "specie "]
+    }
+    
+    # STRATEGY 1: Direct matching from category names
+    for category in categories:
+        # Skip Categories: prefix if present
+        if category.startswith("Category:"):
+            category = category[9:]
+            
+        category_lower = category.lower()
+        
+        # Check for direct taxonomy mentions
+        for rank, patterns in taxonomy_patterns.items():
+            for pattern in patterns:
+                if pattern in category_lower:
+                    # Extract the value after the pattern
+                    parts = category_lower.split(pattern)
+                    if len(parts) > 1:
+                        # Clean up the value (capitalize first letter, remove trailing spaces and special chars)
+                        value = parts[1].strip().split()[0].capitalize()
+                        classification[rank] = value
+                        break
+    
+    # STRATEGY 2: Look for categories that directly match taxonomic naming conventions
+    for category in categories:
+        # Skip Categories: prefix if present
+        if category.startswith("Category:"):
+            category = category[9:]
+            
+        category_parts = category.split()
+        
+        # Check for single-word categories that might be taxonomic names
+        if len(category_parts) == 1:
+            name = category_parts[0]
+            
+            # Check for common taxonomic suffixes
+            if name.endswith("idae"):  # Family suffix for animals
+                classification["family"] = name
+            elif name.endswith("inae"):  # Subfamily suffix
+                # Store subfamily info in a separate key
+                classification["subfamily"] = name
+            elif name.endswith("ales"):  # Order suffix for plants
+                classification["order"] = name
+            elif name.endswith("aceae"):  # Family suffix for plants
+                classification["family"] = name
+            elif name.endswith("ineae"):  # Suborder suffix for plants
+                # Store suborder info in a separate key
+                classification["suborder"] = name
+            elif name.endswith("oideae"):  # Subfamily suffix for plants
+                # Store subfamily info in a separate key
+                classification["subfamily"] = name
+    
+    # STRATEGY 3: Check for categories that contain common taxonomic rank names
+    taxonomic_rank_names = ["kingdom", "phylum", "division", "class", "order", "family", "genus", "species"]
+    for category in categories:
+        # Skip Categories: prefix if present
+        if category.startswith("Category:"):
+            category = category[9:]
+            
+        category_lower = category.lower()
+        
+        for rank in taxonomic_rank_names:
+            if rank in category_lower:
+                # Look for words after the rank name
+                parts = category_lower.split(rank)
+                if len(parts) > 1 and parts[1].strip():
+                    # Get the first word after the rank
+                    value = parts[1].strip().split()[0].capitalize()
+                    if classification[rank] == "Unknown":
+                        classification[rank] = value
+    
+    # Final cleanup: ensure proper capitalization and formatting
+    for rank, value in classification.items():
+        if value != "Unknown":
+            # Capitalize first letter for taxonomic ranks
+            classification[rank] = value[0].upper() + value[1:]
+    
+    return classification
+
+def extract_habitat(description):
+    """
+    Extract habitat information from description using a more comprehensive approach
+    with multiple fallback strategies and pattern recognition.
+    """
+    if not description or description == "No description available":
+        return "Unknown"
+    
+    # Split the description into sentences
+    sentences = description.replace(". ", ".|").replace("! ", "!|").replace("? ", "?|").split("|")
+    sentences = [s.strip() for s in sentences if s.strip()]
+    
+    # STRATEGY 1: Direct habitat statements
+    # Expanded list of habitat-related keywords and phrases
+    habitat_keywords = [
+        "habitat", "lives in", "found in", "native to", "occurs in", "distribution", 
+        "range includes", "ecosystem", "biome", "environment", "inhabits", "dwelling in",
+        "endemic to", "natural range", "geographical range", "distributed across",
+        "prefers", "thrives in", "flourishes in", "resides in", "habitat type",
+        "commonly found", "typically found", "often found", "usually found", "primarily found"
+    ]
+    
+    # STRATEGY 2: Geography and climate context
+    # Climate and geography keywords to catch broader context
+    climate_keywords = [
+        "tropical", "temperate", "polar", "arctic", "antarctic", "desert", 
+        "rainforest", "forest", "jungle", "grassland", "savanna", "wetland", 
+        "marsh", "swamp", "mountain", "alpine", "coastal", "marine", "freshwater",
+        "ocean", "sea", "river", "lake", "stream", "pond", "terrestrial", "aquatic",
+        "woodland", "meadow", "tundra", "taiga", "steppe", "continent", "island",
+        "shore", "beach", "reef", "cave", "burrow", "nest", "canopy", "undergrowth"
+    ]
+    
+    # STRATEGY 3: Regional indicators (continents, regions, countries)
+    region_keywords = [
+        "africa", "asia", "europe", "north america", "south america", "australia", 
+        "antarctica", "oceania", "mediterranean", "pacific", "atlantic", "indian ocean",
+        "arctic ocean", "southern ocean", "northern", "southern", "eastern", "western",
+        "central", "worldwide", "global", "cosmopolitan", "international"
+    ]
+    
+    # STRATEGY 4: Verbs that might indicate location or movement patterns
+    action_keywords = [
+        "migrate", "roam", "travel", "swim", "fly", "climb", "burrow", "dig", "nest", 
+        "breed", "forage", "hunt", "territory", "range"
+    ]
+    
+    # Sentences that might contain habitat information
+    habitat_sentences = []
+    
+    # Apply Strategy 1: Direct habitat statements
+    for sentence in sentences:
+        for keyword in habitat_keywords:
+            if keyword.lower() in sentence.lower():
+                habitat_sentences.append(sentence)
+                break
+    
+    # Apply Strategy 2: Geography and climate context (if strategy 1 didn't yield results)
+    if not habitat_sentences:
+        for sentence in sentences:
+            for keyword in climate_keywords:
+                if keyword.lower() in sentence.lower():
+                    habitat_sentences.append(sentence)
+                    break
+    
+    # Apply Strategy 3: Regional indicators (if strategies 1-2 didn't yield results)
+    if not habitat_sentences:
+        for sentence in sentences:
+            for keyword in region_keywords:
+                if keyword.lower() in sentence.lower():
+                    habitat_sentences.append(sentence)
+                    break
+    
+    # Apply Strategy 4: Action verbs related to habitat (if strategies 1-3 didn't yield results)
+    if not habitat_sentences:
+        for sentence in sentences:
+            for keyword in action_keywords:
+                if keyword.lower() in sentence.lower():
+                    habitat_sentences.append(sentence)
+                    break
+    
+    # Fallback Strategy: If no habitat information was found, try to use the first or second sentence
+    # as they often contain general information about where the species lives
+    if not habitat_sentences and len(sentences) >= 2:
+        # Skip the first sentence if it's just a definition and take the second
+        if len(sentences) > 2:
+            second_sentence = sentences[1]
+            # Check if the second sentence has reasonable length to be informative
+            if len(second_sentence.split()) > 5:
+                habitat_sentences.append(second_sentence)
+        
+        # If second sentence wasn't suitable or not available, use the first
+        if not habitat_sentences:
+            first_sentence = sentences[0]
+            if len(first_sentence.split()) > 5:
+                habitat_sentences.append(first_sentence)
+    
+    # Format the habitat information
+    if habitat_sentences:
+        # If we have multiple sentences, join them (but limit to 2 for conciseness)
+        if len(habitat_sentences) > 1:
+            combined = ". ".join(habitat_sentences[:2]).strip()
+            # Make sure it ends with proper punctuation
+            if not combined.endswith(('.', '!', '?')):
+                combined += '.'
+            return combined
+        
+        single = habitat_sentences[0].strip()
+        # Make sure it ends with proper punctuation
+        if not single.endswith(('.', '!', '?')):
+            single += '.'
+        return single
+    
+    # Last resort: construct a generic message if we couldn't find specific habitat info
+    return "Specific habitat information not available from Wikispecies. Try searching online for more details about this species' natural environment."
+
+def extract_fun_facts(description):
+    """
+    Extract interesting fun facts from the description using keyword-based identification,
+    with improved pattern recognition and a structured approach to generate fun facts
+    even with limited information.
+    """
+    if not description or description == "No description available":
+        return ["No specific information available for this species in Wikispecies."]
+    
+    # Split the description into sentences
+    sentences = description.replace(". ", ".|").replace("! ", "!|").replace("? ", "?|").split("|")
+    sentences = [s.strip() for s in sentences if s.strip()]
+    
+    # If the description is too short, include it as a single fact
+    if len(sentences) == 1 and len(description) < 100:
+        if not sentences[0].endswith(('.', '!', '?')):
+            sentences[0] += '.'
+        return [sentences[0]]
+    
+    # STRATEGY 1: Identify sentences with interesting keywords
+    interesting_keywords = [
+        "interesting", "unique", "unusual", "remarkable", "notable", "surprising",
+        "fascinating", "amazing", "extraordinary", "distinctive", "special", "rare",
+        "strange", "curious", "unlike", "peculiar", "odd", "bizarre", "striking",
+        "colorful", "beautiful", "impressive", "popular", "famous", "well-known",
+        "largest", "smallest", "fastest", "slowest", "oldest", "youngest", "only",
+        "record", "discovery", "first", "last", "origin", "discovered", "introduced",
+        "revered", "sacred", "symbol", "iconic", "emblem", "represented", "mythology",
+        "legend", "folklore", "traditional", "cultural", "significance", "historical"
+    ]
+    
+    # STRATEGY 2: Physical characteristics and biology often make good facts
+    biology_keywords = [
+        "lifespan", "longevity", "size", "weight", "height", "length", "wingspan",
+        "color", "pattern", "marking", "appearance", "physical", "morphology", "anatomy",
+        "feature", "characteristic", "distinctive", "body", "shape", "structure",
+        "adaptation", "evolved", "evolution", "mutation", "gene", "genetic", "chromosome",
+        "hybrid", "species", "subspecies", "variety", "breed", "strain", "extinct",
+        "endangered", "threatened", "vulnerable", "conservation", "protected"
+    ]
+    
+    # STRATEGY 3: Behavior and lifestyle information
+    behavior_keywords = [
+        "diet", "eat", "feeding", "food", "prey", "predator", "hunt", "scavenge",
+        "forage", "graze", "browse", "omnivore", "carnivore", "herbivore", "insectivore",
+        "behavior", "behaviour", "habit", "activity", "social", "solitary", "group",
+        "herd", "flock", "pack", "colony", "community", "family", "nocturnal", "diurnal",
+        "crepuscular", "migrate", "migration", "hibernate", "hibernation", "estivate",
+        "dormant", "sleep", "rest", "active", "territory", "defend", "aggressive",
+        "docile", "tame", "wild", "domestic", "domesticated", "trained", "human"
+    ]
+    
+    # STRATEGY 4: Reproduction is always interesting
+    reproduction_keywords = [
+        "reproduce", "reproduction", "breeding", "mate", "mating", "courtship", "display",
+        "attract", "offspring", "young", "juvenile", "infant", "baby", "child", "adult",
+        "egg", "spawn", "birth", "pregnant", "gestation", "incubation", "hatch", "nestling",
+        "fledgling", "litter", "clutch", "brood", "parent", "care", "raise", "nurse", "wean"
+    ]
+    
+    # Comparative patterns that often indicate interesting facts
+    comparative_patterns = [
+        "more than", "less than", "bigger than", "smaller than", "larger than",
+        "faster than", "slower than", "better than", "worse than", "greater than",
+        "unlike", "similar to", "compared to", "in contrast to", "differs from",
+        "up to", "as many as", "can reach", "can grow", "can live", "known to",
+        "capable of", "able to", "estimated", "approximately", "about", "around"
+    ]
+    
+    # Measurement patterns that often indicate interesting statistics
+    measurement_patterns = [
+        "cm", "meter", "metre", "kilometer", "kilometre", "feet", "foot", "inch",
+        "kg", "gram", "pound", "ton", "tonne", "year", "month", "week", "day", "hour",
+        "percent", "°C", "°F", "degree", "celsius", "fahrenheit", "temperature", 
+        "speed", "mph", "kph", "knot", "altitude", "depth", "width", "height"
+    ]
+    
+    # Collect potential facts using different strategies
+    fact_candidates = {
+        "interesting": [],
+        "biological": [],
+        "behavioral": [],
+        "reproductive": [],
+        "comparative": [],
+        "measurements": [],
+        "general": []
+    }
+    
+    # Apply strategies to collect potential facts
+    for sentence in sentences:
+        # Skip very short sentences
+        if len(sentence.split()) < 4:
+            continue
+            
+        # Flag to track if the sentence has been categorized
+        categorized = False
+        
+        # Strategy 1: Interesting keywords
+        for keyword in interesting_keywords:
+            if keyword.lower() in sentence.lower():
+                fact_candidates["interesting"].append(sentence)
+                categorized = True
+                break
+                
+        if not categorized:
+            # Strategy 2: Biological characteristics
+            for keyword in biology_keywords:
+                if keyword.lower() in sentence.lower():
+                    fact_candidates["biological"].append(sentence)
+                    categorized = True
+                    break
+        
+        if not categorized:
+            # Strategy 3: Behavior keywords
+            for keyword in behavior_keywords:
+                if keyword.lower() in sentence.lower():
+                    fact_candidates["behavioral"].append(sentence)
+                    categorized = True
+                    break
+                    
+        if not categorized:
+            # Strategy 4: Reproduction keywords
+            for keyword in reproduction_keywords:
+                if keyword.lower() in sentence.lower():
+                    fact_candidates["reproductive"].append(sentence)
+                    categorized = True
+                    break
+        
+        if not categorized:
+            # Check for comparative patterns
+            for pattern in comparative_patterns:
+                if pattern.lower() in sentence.lower():
+                    fact_candidates["comparative"].append(sentence)
+                    categorized = True
+                    break
+                    
+        if not categorized:
+            # Check for measurement patterns
+            has_number = any(c.isdigit() for c in sentence)
+            if has_number:
+                for pattern in measurement_patterns:
+                    if pattern.lower() in sentence.lower():
+                        fact_candidates["measurements"].append(sentence)
+                        categorized = True
+                        break
+                        fact_candidates["measurements"].append(sentence)
+                        categorized = True
+                        break
+        
+        # If sentence wasn't categorized by any specific strategy, add to general
+        if not categorized and len(sentence.split()) > 5:
+            fact_candidates["general"].append(sentence)
+    
+    # Select facts from each category to ensure diversity (prioritizing the most interesting ones)
+    selected_facts = []
+    
+    # Priority order for fact selection
+    categories = ["interesting", "measurements", "biological", "reproductive", "behavioral", "comparative", "general"]
+    
+    # First, try to get at least one fact from high-priority categories
+    for category in categories[:3]:  # First 3 are highest priority
+        if fact_candidates[category]:
+            selected_facts.append(fact_candidates[category][0])
+            fact_candidates[category].pop(0)  # Remove the used fact
+    
+    # Now fill remaining slots with a mix of all categories
+    remaining_slots = 4 - len(selected_facts)  # Maximum 4 facts total
+    
+    if remaining_slots > 0:
+        for category in categories:
+            if fact_candidates[category] and remaining_slots > 0:
+                next_fact = fact_candidates[category][0]
+                # Only add if not too similar to already selected facts
+                if not any(similarity_score(next_fact, fact) > 0.7 for fact in selected_facts):
+                    selected_facts.append(next_fact)
+                    remaining_slots -= 1
+                fact_candidates[category].pop(0)  # Remove the used fact
+    
+    # If we still don't have enough facts, add more from general pool
+    if len(selected_facts) < 2 and sentences:
+        # Add the first sentence if it's not already included
+        if sentences[0] not in selected_facts and len(sentences[0].split()) > 5:
+            selected_facts.append(sentences[0])
+            
+        # Add another sentence from middle of the text if available
+        middle_idx = len(sentences) // 2
+        if len(sentences) > middle_idx and sentences[middle_idx] not in selected_facts and len(sentences[middle_idx].split()) > 5:
+            selected_facts.append(sentences[middle_idx])
+    
+    # Last resort: if still no facts, create a generic fact
+    if not selected_facts:
+        selected_facts = ["This species is documented in Wikispecies, the free species directory."]
+    
+    # Ensure all facts end with proper punctuation
+    for i in range(len(selected_facts)):
+        if not selected_facts[i].endswith(('.', '!', '?')):
+            selected_facts[i] += '.'
+    
+    # Remove duplicates while preserving order
+    unique_facts = []
+    for fact in selected_facts:
+        if fact not in unique_facts:
+            unique_facts.append(fact)
+    
+    return unique_facts[:4]  # Limit to max 4 facts
+
+def similarity_score(str1, str2):
+    """
+    Calculate a simple similarity score between two strings
+    based on word overlap. Used to avoid selecting too similar facts.
+    Returns a value between 0 (completely different) and 1 (identical).
+    """
+    if not str1 or not str2:
+        return 0
+        
+    # Convert to lowercase and split into words
+    words1 = set(str1.lower().split())
+    words2 = set(str2.lower().split())
+    
+    # Calculate Jaccard similarity
+    intersection = words1.intersection(words2)
+    union = words1.union(words2)
+    
+    if not union:
+        return 0
+        
+    return len(intersection) / len(union)
+
+def get_mock_species_from_filename(filename):
+    """
+    A mock function that simulates image recognition by looking at the filename.
+    In a real application, this would be replaced with an actual image recognition API.
+    """
+    filename_lower = filename.lower()
+    
+    # List of common animals and their possible filenames
+    animal_keywords = {
+        "cat": "Felis catus",
+        "dog": "Canis familiaris",
+        "bird": "Aves",
+        "eagle": "Aquila chrysaetos",
+        "lion": "Panthera leo",
+        "tiger": "Panthera tigris",
+        "bear": "Ursus arctos",
+        "wolf": "Canis lupus",
+        "fox": "Vulpes vulpes",
+        "deer": "Cervidae",
+        "elephant": "Loxodonta africana",
+        "giraffe": "Giraffa camelopardalis",
+        "zebra": "Equus quagga",
+        "monkey": "Primates",
+        "gorilla": "Gorilla gorilla",
+        "fish": "Actinopterygii",
+        "shark": "Selachimorpha",
+        "dolphin": "Tursiops truncatus",
+        "whale": "Cetacea",
+        "snake": "Serpentes",
+        "lizard": "Lacertilia",
+        "turtle": "Testudines",
+        "frog": "Anura",
+        "butterfly": "Lepidoptera",
+        "bee": "Apis mellifera",
+    }
+    
+    # List of common plants and their possible filenames
+    plant_keywords = {
+        "tree": "Arbor",
+        "flower": "Anthophyta",
+        "rose": "Rosa",
+        "tulip": "Tulipa",
+        "daisy": "Bellis perennis",
+        "sunflower": "Helianthus annuus",
+        "oak": "Quercus",
+        "pine": "Pinus",
+        "maple": "Acer",
+        "fern": "Polypodiopsida",
+        "moss": "Bryophyta",
+        "grass": "Poaceae",
+        "cactus": "Cactaceae",
+        "palm": "Arecaceae",
+        "orchid": "Orchidaceae",
+    }
+    
+    # Check animal keywords
+    for keyword, species in animal_keywords.items():
+        if keyword in filename_lower:
+            return species
+    
+    # Check plant keywords
+    for keyword, species in plant_keywords.items():
+        if keyword in filename_lower:
+            return species
+    
+    # If no match is found, return a default species
+    return "Homo sapiens"
+
+def extract_wikipedia_classification(full_text, title, search_data=None):
+    """
+    Extract classification/taxonomy information from Wikipedia content.
+    Uses various strategies including infobox parsing, section analysis, and text pattern matching.
+    
+    Args:
+        full_text: The full text content of the Wikipedia page
+        title: The title of the Wikipedia page
+        search_data: Optional search data that might contain additional info
+        
+    Returns:
+        A dictionary with taxonomic ranks and their values
+    """
+    # Initialize with default "Unknown" values
+    classification = {
+        "kingdom": "Unknown",
+        "phylum": "Unknown",
+        "class": "Unknown",
+        "order": "Unknown",
+        "family": "Unknown",
+        "genus": "Unknown",
+        "species": "Unknown"
+    }
+    
+    if not full_text:
+        return classification
+    
+    try:
+        # STRATEGY 1: Look for taxonomic information in specific sections
+        taxonomy_section = extract_wikipedia_section(full_text, ["Taxonomy", "Classification", "Taxonomic", "Scientific classification"])
+        if taxonomy_section:
+            # Extract taxonomic information from the section
+            classification = extract_taxonomy_from_text(taxonomy_section, classification)
+        
+        # STRATEGY 2: Look for taxonomic information in infobox-like structures
+        # Wikipedia infoboxes often appear at the beginning of the text with structured format
+        infobox_patterns = [
+            r"Kingdom:\s*([A-Za-z]+)",
+            r"Phylum:\s*([A-Za-z]+)",
+            r"Class:\s*([A-Za-z]+)",
+            r"Order:\s*([A-Za-z]+)",
+            r"Family:\s*([A-Za-z]+)",
+            r"Genus:\s*([A-Za-z]+)",
+            r"Species:\s*([A-Za-z]+)"
+        ]
+        
+        # Apply each pattern to extract taxonomic information
+        for i, pattern in enumerate(infobox_patterns):
+            rank = list(classification.keys())[i]
+            matches = re.findall(pattern, full_text, re.IGNORECASE)
+            if matches:
+                classification[rank] = matches[0].strip()
+        
+        # STRATEGY 3: Parse the first paragraph for taxonomic information
+        # First paragraphs in Wikipedia often contain taxonomic statements
+        first_para = full_text.split('\n\n')[0] if '\n\n' in full_text else full_text
+        classification = extract_taxonomy_from_text(first_para, classification)
+        
+        # STRATEGY 4: Try to extract genus and species from the title
+        title_parts = title.split()
+        if len(title_parts) >= 2 and classification["genus"] == "Unknown":
+            # If title looks like a binomial name (e.g., "Panthera leo")
+            if title_parts[0][0].isupper() and title_parts[0][1:].islower() and title_parts[1].islower():
+                classification["genus"] = title_parts[0]
+                if classification["species"] == "Unknown":
+                    classification["species"] = title_parts[1]
+        
+        # STRATEGY 5: Look for taxonomic statements throughout the text
+        # These patterns match statements like "belongs to the family Felidae"
+        taxonomy_statement_patterns = [
+            r"(?:belongs|belonging)\s+to\s+(?:the)?\s+kingdom\s+([A-Za-z]+)",
+            r"(?:belongs|belonging)\s+to\s+(?:the)?\s+phylum\s+([A-Za-z]+)",
+            r"(?:belongs|belonging)\s+to\s+(?:the)?\s+class\s+([A-Za-z]+)",
+            r"(?:belongs|belonging)\s+to\s+(?:the)?\s+order\s+([A-Za-z]+)",
+            r"(?:belongs|belonging)\s+to\s+(?:the)?\s+family\s+([A-Za-z]+)",
+            r"(?:is|as)\s+a\s+(?:member|species)\s+of\s+(?:the)?\s+kingdom\s+([A-Za-z]+)",
+            r"(?:is|as)\s+a\s+(?:member|species)\s+of\s+(?:the)?\s+phylum\s+([A-Za-z]+)",
+            r"(?:is|as)\s+a\s+(?:member|species)\s+of\s+(?:the)?\s+class\s+([A-Za-z]+)",
+            r"(?:is|as)\s+a\s+(?:member|species)\s+of\s+(?:the)?\s+order\s+([A-Za-z]+)",
+            r"(?:is|as)\s+a\s+(?:member|species)\s+of\s+(?:the)?\s+family\s+([A-Za-z]+)",
+            r"(?:is|as)\s+a\s+(?:member|species)\s+of\s+(?:the)?\s+genus\s+([A-Za-z]+)"
+        ]
+        
+        # Map patterns to taxonomic ranks
+        rank_map = {
+            0: "kingdom", 1: "phylum", 2: "class", 3: "order", 4: "family",
+            5: "kingdom", 6: "phylum", 7: "class", 8: "order", 9: "family", 10: "genus"
+        }
+        
+        # Apply statement patterns to extract taxonomic information
+        for i, pattern in enumerate(taxonomy_statement_patterns):
+            rank = rank_map.get(i)
+            if not rank:
+                continue
+                
+            matches = re.findall(pattern, full_text, re.IGNORECASE)
+            if matches and classification[rank] == "Unknown":
+                classification[rank] = matches[0].strip()
+        
+        # Final cleanup: ensure proper capitalization and formatting
+        for rank, value in classification.items():
+            if value != "Unknown":
+                # Capitalize first letter for taxonomic ranks
+                classification[rank] = value[0].upper() + value[1:]
+    
+    except Exception as e:
+        print(f"Error extracting classification from Wikipedia: {str(e)}")
+        # If an error occurs, we'll return the classification with whatever data we managed to extract
+    
+    return classification
+
+def extract_taxonomy_from_text(text, classification):
+    """
+    Extract taxonomic information from text using pattern matching
+    and natural language processing techniques.
+    
+    Args:
+        text: The text to analyze
+        classification: The current classification dictionary to update
+        
+    Returns:
+        Updated classification dictionary
+    """
+    if not text:
+        return classification
+    
+    try:
+        # Common patterns for taxonomic ranks in text
+        taxonomy_patterns = {
+            "kingdom": [r"Kingdom:?\s*([A-Za-z]+)", r"Kingdom\s+([A-Za-z]+)", r"a member of the kingdom\s+([A-Za-z]+)"],
+            "phylum": [r"Phylum:?\s*([A-Za-z]+)", r"Phylum\s+([A-Za-z]+)", r"a member of the phylum\s+([A-Za-z]+)"],
+            "class": [r"Class:?\s*([A-Za-z]+)", r"Class\s+([A-Za-z]+)", r"a member of the class\s+([A-Za-z]+)"],
+            "order": [r"Order:?\s*([A-Za-z]+)", r"Order\s+([A-Za-z]+)", r"a member of the order\s+([A-Za-z]+)"],
+        }
+        
+        # For each taxonomic rank, try to find matches using the patterns
+        for rank, patterns in taxonomy_patterns.items():
+            if classification[rank] != "Unknown":
+                continue  # Skip if we already have a value
+                
+            for pattern in patterns:
+                matches = re.findall(pattern, text, re.IGNORECASE)
+                if matches:
+                    # Take the first match and clean it up
+                    match = matches[0].strip()
+                    # Handle Latin taxonomic names with proper capitalization
+                    if rank in ["genus", "species"]:
+                        match = match[0].upper() + match[1:].lower()
+                    elif rank != "species":  # For non-species ranks
+                        match = match.capitalize()
+                    
+                    classification[rank] = match
+                    break  # Stop after finding a match for this rank
+        
+        # Look for taxonomic information with specific taxonomic suffixes
+        suffix_patterns = {
+            "family": [r"\b([A-Za-z]+idae)\b", r"\b([A-Za-z]+aceae)\b"],  # Animal and plant families
+            "order": [r"\b([A-Za-z]+ales)\b", r"\b([A-Za-z]+ida)\b"],  # Plant orders and animal orders
+            "class": [r"\b([A-Za-z]+ia)\b", r"\b([A-Za-z]+phyceae)\b"],  # Classes
+            "phylum": [r"\b([A-Za-z]+phyta)\b", r"\b([A-Za-z]+zoa)\b"]  # Plant and animal phyla
+        }
+        
+        # Apply suffix patterns to extract taxonomic information
+        for rank, patterns in suffix_patterns.items():
+            if classification[rank] != "Unknown":
+                continue  # Skip if we already have a value
+                
+            for pattern in patterns:
+                matches = re.findall(pattern, text)
+                if matches:
+                    # Take the first match and clean it up
+                    match = matches[0].strip()
+                    classification[rank] = match
+                    break
+                
+    except Exception as e:
+        print(f"Error in extract_taxonomy_from_text: {str(e)}")
+        # If an error occurs, return the classification as is
+    
+    return classification
+
+if _name_ == "_main_":
+    main()