Uploaded app files

app.py

@@ -0,0 +1,15 @@
+import streamlit as st
+from echoanimal import main as echoanimal_main
+from wiki_taxonomy import main as wiki_taxonomy_main
+
+# Sidebar Navigation
+st.sidebar.title("Choose an Application")
+app_choice = st.sidebar.radio("Select App:", ["Animal Sound Translator", "Animal Taxonomy Classifier"])
+
+# App Navigation Logic
+if app_choice == "Animal Sound Translator":
+    st.title("Animal Sound Translator")
+    echoanimal_main()
+elif app_choice == "Animal Taxonomy Classifier":
+    st.title("Animal Taxonomy Classifier")
+    wiki_taxonomy_main()

echoanimal.py

@@ -0,0 +1,541 @@
+import streamlit as st
+import numpy as np
+import librosa
+import matplotlib.pyplot as plt
+import seaborn as sns
+from scipy import signal
+import io
+import base64
+from transformers import pipeline, AutoFeatureExtractor, AutoModelForAudioClassification
+import torch
+import warnings
+warnings.filterwarnings('ignore')
+
+# Set page config
+st.set_page_config(
+    page_title="🐾 Animal Sound Translator",
+    page_icon="🐾",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS for better styling
+st.markdown("""
+<style>
+    .main-header {
+        font-size: 3rem;
+        font-weight: bold;
+        text-align: center;
+        background: linear-gradient(90deg, #FF6B6B, #4ECDC4, #45B7D1);
+        -webkit-background-clip: text;
+        -webkit-text-fill-color: transparent;
+        margin-bottom: 2rem;
+    }
+    
+    .metric-card {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        padding: 1rem;
+        border-radius: 10px;
+        color: white;
+        text-align: center;
+        margin: 0.5rem 0;
+    }
+    
+    .animal-card {
+        background: linear-gradient(135deg, #f093fb 0%, #f5576c 100%);
+        padding: 1.5rem;
+        border-radius: 15px;
+        color: white;
+        text-align: center;
+        margin: 1rem 0;
+        box-shadow: 0 4px 15px rgba(0,0,0,0.2);
+    }
+    
+    .translation-card {
+        background: linear-gradient(135deg, #4facfe 0%, #00f2fe 100%);
+        padding: 1.5rem;
+        border-radius: 15px;
+        color: white;
+        margin: 1rem 0;
+        box-shadow: 0 4px 15px rgba(0,0,0,0.2);
+    }
+    
+    .confidence-bar {
+        background: linear-gradient(90deg, #ff9a9e 0%, #fecfef 50%, #fecfef 100%);
+        height: 20px;
+        border-radius: 10px;
+        margin: 0.5rem 0;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Initialize session state
+if 'audio_data' not in st.session_state:
+    st.session_state.audio_data = None
+if 'sample_rate' not in st.session_state:
+    st.session_state.sample_rate = None
+
+@st.cache_resource
+def load_models():
+    """Load pre-trained models for audio classification"""
+    try:
+        # Load a general audio classification model
+        feature_extractor = AutoFeatureExtractor.from_pretrained("MIT/ast-finetuned-audioset-10-10-0.4593")
+        model = AutoModelForAudioClassification.from_pretrained("MIT/ast-finetuned-audioset-10-10-0.4593")
+        classifier = pipeline("audio-classification", 
+                            model=model, 
+                            feature_extractor=feature_extractor)
+        return classifier
+    except Exception as e:
+        st.error(f"Error loading models: {e}")
+        return None
+
+def analyze_audio_features(audio_data, sr):
+    """Extract comprehensive audio features"""
+    features = {}
+    
+    # Basic features
+    features['duration'] = len(audio_data) / sr
+    features['sample_rate'] = sr
+    features['rms_energy'] = np.sqrt(np.mean(audio_data**2))
+    
+    # Spectral features
+    features['spectral_centroid'] = np.mean(librosa.feature.spectral_centroid(y=audio_data, sr=sr))
+    features['spectral_bandwidth'] = np.mean(librosa.feature.spectral_bandwidth(y=audio_data, sr=sr))
+    features['spectral_rolloff'] = np.mean(librosa.feature.spectral_rolloff(y=audio_data, sr=sr))
+    features['zero_crossing_rate'] = np.mean(librosa.feature.zero_crossing_rate(audio_data))
+    
+    # MFCC features
+    mfccs = librosa.feature.mfcc(y=audio_data, sr=sr, n_mfcc=13)
+    for i in range(13):
+        features[f'mfcc_{i+1}'] = np.mean(mfccs[i])
+    
+    # Pitch and tempo
+    try:
+        pitches, magnitudes = librosa.piptrack(y=audio_data, sr=sr)
+        pitch_values = []
+        for t in range(pitches.shape[1]):
+            index = magnitudes[:, t].argmax()
+            pitch = pitches[index, t]
+            if pitch > 0:
+                pitch_values.append(pitch)
+        features['avg_pitch'] = np.mean(pitch_values) if pitch_values else 0
+        features['pitch_std'] = np.std(pitch_values) if pitch_values else 0
+    except:
+        features['avg_pitch'] = 0
+        features['pitch_std'] = 0
+    
+    return features
+
+def classify_animal_sound(audio_data, sr, classifier):
+    """Classify the animal sound using pre-trained model"""
+    try:
+        # Resample to 16kHz if needed (common requirement for audio models)
+        if sr != 16000:
+            audio_data = librosa.resample(audio_data, orig_sr=sr, target_sr=16000)
+            sr = 16000
+        
+        # Ensure audio is not too long (limit to 30 seconds)
+        max_length = 30 * sr
+        if len(audio_data) > max_length:
+            audio_data = audio_data[:max_length]
+        
+        # Get predictions
+        predictions = classifier(audio_data, sampling_rate=sr)
+        
+        # Filter for animal-related sounds
+        animal_keywords = ['dog', 'cat', 'bird', 'cow', 'horse', 'pig', 'sheep', 'goat', 
+                          'chicken', 'duck', 'rooster', 'bark', 'meow', 'chirp', 'moo', 
+                          'neigh', 'oink', 'baa', 'cluck', 'quack', 'crow', 'howl', 'purr']
+        
+        animal_predictions = []
+        for pred in predictions:
+            label_lower = pred['label'].lower()
+            if any(keyword in label_lower for keyword in animal_keywords):
+                animal_predictions.append(pred)
+        
+        # If no animal sounds found, return top predictions anyway
+        if not animal_predictions:
+            animal_predictions = predictions[:3]
+        
+        return animal_predictions[:5]  # Return top 5
+        
+    except Exception as e:
+        st.error(f"Error in classification: {e}")
+        return []
+
+def generate_translation(animal_type, confidence, audio_features):
+    """Generate human-readable translation based on animal type and audio features"""
+    
+    # Animal behavior patterns and translations
+    translations = {
+        'dog': {
+            'high_pitch': "I'm excited! Let's play!",
+            'low_pitch': "I'm being protective or warning you.",
+            'rapid': "I'm very excited or anxious!",
+            'slow': "I'm calm but want your attention.",
+            'loud': "I need something urgently!",
+            'soft': "I'm content and happy.",
+            'default': "Woof! I'm trying to communicate with you!"
+        },
+        'cat': {
+            'high_pitch': "I want something! Feed me or pet me!",
+            'low_pitch': "I'm content and relaxed.",
+            'rapid': "I'm frustrated or demanding attention!",
+            'slow': "I'm greeting you or feeling social.",
+            'loud': "I'm upset or in distress!",
+            'soft': "I'm happy and comfortable.",
+            'default': "Meow! I'm talking to you, human!"
+        },
+        'bird': {
+            'high_pitch': "I'm alerting others or expressing joy!",
+            'low_pitch': "I'm establishing territory or calling for a mate.",
+            'rapid': "I'm excited or warning of danger!",
+            'slow': "I'm content and peaceful.",
+            'loud': "I'm calling to my flock or defending my space!",
+            'soft': "I'm content and comfortable.",
+            'default': "Tweet! I'm singing my song!"
+        },
+        'cow': {
+            'high_pitch': "I'm looking for my calf or feeling distressed!",
+            'low_pitch': "I'm calm and content.",
+            'loud': "I need attention or I'm calling to the herd!",
+            'soft': "I'm peaceful and relaxed.",
+            'default': "Moo! I'm communicating with my herd!"
+        },
+        'default': {
+            'high_pitch': "I'm expressing excitement or alertness!",
+            'low_pitch': "I'm calm or showing dominance.",
+            'rapid': "I'm excited, anxious, or trying to get attention!",
+            'slow': "I'm relaxed and content.",
+            'loud': "I need attention or I'm expressing strong emotion!",
+            'soft': "I'm comfortable and peaceful.",
+            'default': "I'm trying to communicate something important!"
+        }
+    }
+    
+    # Determine animal category
+    animal_key = 'default'
+    for key in translations.keys():
+        if key in animal_type.lower():
+            animal_key = key
+            break
+    
+    # Analyze audio characteristics
+    pitch = audio_features.get('avg_pitch', 0)
+    energy = audio_features.get('rms_energy', 0)
+    zcr = audio_features.get('zero_crossing_rate', 0)
+    
+    # Determine characteristics
+    characteristics = []
+    if pitch > 300:
+        characteristics.append('high_pitch')
+    elif pitch > 0 and pitch < 200:
+        characteristics.append('low_pitch')
+    
+    if energy > 0.1:
+        characteristics.append('loud')
+    elif energy < 0.05:
+        characteristics.append('soft')
+    
+    if zcr > 0.1:
+        characteristics.append('rapid')
+    elif zcr < 0.05:
+        characteristics.append('slow')
+    
+    # Get translation
+    translation_dict = translations[animal_key]
+    translation = translation_dict.get('default', "I'm trying to communicate!")
+    
+    # Use most specific characteristic available
+    for char in characteristics:
+        if char in translation_dict:
+            translation = translation_dict[char]
+            break
+    
+    # Add confidence-based modifier
+    if confidence < 0.3:
+        translation = f"[Uncertain] {translation}"
+    elif confidence > 0.8:
+        translation = f"[Very Confident] {translation}"
+    
+    return translation
+
+def create_spectrogram(audio_data, sr):
+    """Create and return spectrogram plot"""
+    fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 8))
+    
+    # Waveform
+    time = np.linspace(0, len(audio_data)/sr, len(audio_data))
+    ax1.plot(time, audio_data, color='#4ECDC4', linewidth=1)
+    ax1.set_title('Audio Waveform', fontsize=14, fontweight='bold')
+    ax1.set_xlabel('Time (seconds)')
+    ax1.set_ylabel('Amplitude')
+    ax1.grid(True, alpha=0.3)
+    
+    # Spectrogram
+    D = librosa.amplitude_to_db(np.abs(librosa.stft(audio_data)), ref=np.max)
+    img = librosa.display.specshow(D, y_axis='hz', x_axis='time', sr=sr, ax=ax2, cmap='viridis')
+    ax2.set_title('Spectrogram', fontsize=14, fontweight='bold')
+    plt.colorbar(img, ax=ax2, format='%+2.0f dB')
+    
+    plt.tight_layout()
+    return fig
+
+def main():
+    # Header
+    st.markdown('<h1 class="main-header">🐾 Animal Sound Translator</h1>', unsafe_allow_html=True)
+    st.markdown("### 🐾 Animal sound Translator ###")
+    
+    # Load models
+    with st.spinner("Loading AI models..."):
+        classifier = load_models()
+    
+    if classifier is None:
+        st.error("Failed to load models. Please refresh the page.")
+        return
+    
+    # Sidebar
+    st.sidebar.header("🎵 Audio Input")
+    
+    # Audio input options
+    input_method = st.sidebar.radio(
+        "Choose input method:",
+        ["Upload Audio File", "Record Audio (if supported)"]
+    )
+    
+    audio_file = None
+    if input_method == "Upload Audio File":
+        audio_file = st.sidebar.file_uploader(
+            "Upload an audio file",
+            type=['wav', 'mp3', 'ogg', 'flac', 'm4a'],
+            help="Upload an audio file containing animal sounds"
+        )
+    
+    # Process audio
+    if audio_file is not None:
+        try:
+            # Load audio
+            audio_data, sample_rate = librosa.load(audio_file, sr=None)
+            st.session_state.audio_data = audio_data
+            st.session_state.sample_rate = sample_rate
+            
+            # Display audio player
+            st.sidebar.audio(audio_file, format='audio/wav')
+            
+            # Main analysis
+            col1, col2 = st.columns([2, 1])
+            
+            with col1:
+                st.subheader("🔊 Audio Analysis")
+                
+                # Create spectrogram
+                with st.spinner("Generating spectrogram..."):
+                    fig = create_spectrogram(audio_data, sample_rate)
+                    st.pyplot(fig)
+                    plt.close()
+            
+            with col2:
+                st.subheader("📊 Audio Properties")
+                
+                # Basic audio info
+                duration = len(audio_data) / sample_rate
+                st.metric("Duration", f"{duration:.2f} seconds")
+                st.metric("Sample Rate", f"{sample_rate} Hz")
+                st.metric("Channels", "Mono")
+                
+                # Audio features
+                features = analyze_audio_features(audio_data, sample_rate)
+                
+                st.metric("RMS Energy", f"{features['rms_energy']:.4f}")
+                st.metric("Avg Pitch", f"{features['avg_pitch']:.1f} Hz")
+                st.metric("Spectral Centroid", f"{features['spectral_centroid']:.1f} Hz")
+            
+            # Animal Classification
+            st.subheader("🐾 Animal Identification")
+            
+            with st.spinner("Analyzing animal sounds..."):
+                predictions = classify_animal_sound(audio_data, sample_rate, classifier)
+            
+            if predictions:
+                # Display top prediction
+                top_prediction = predictions[0]
+                confidence = top_prediction['score']
+                animal_type = top_prediction['label']
+                
+                # Animal identification card
+                st.markdown(f"""
+                <div class="animal-card">
+                    <h2>🎯 Identified Animal</h2>
+                    <h3>{animal_type.title()}</h3>
+                    <p>Confidence: {confidence:.1%}</p>
+                </div>
+                """, unsafe_allow_html=True)
+                
+                # Confidence visualization
+                st.subheader("📈 Confidence Levels")
+                conf_col1, conf_col2 = st.columns(2)
+                
+                with conf_col1:
+                    # Create confidence chart
+                    labels = [pred['label'][:20] + '...' if len(pred['label']) > 20 else pred['label'] 
+                             for pred in predictions[:5]]
+                    scores = [pred['score'] for pred in predictions[:5]]
+                    
+                    fig, ax = plt.subplots(figsize=(8, 6))
+                    bars = ax.barh(labels, scores, color=['#FF6B6B', '#4ECDC4', '#45B7D1', '#96CEB4', '#FFEAA7'])
+                    ax.set_xlabel('Confidence Score')
+                    ax.set_title('Top 5 Predictions')
+                    ax.set_xlim(0, 1)
+                    
+                    # Add value labels on bars
+                    for i, (bar, score) in enumerate(zip(bars, scores)):
+                        ax.text(score + 0.01, bar.get_y() + bar.get_height()/2, 
+                               f'{score:.1%}', va='center', fontweight='bold')
+                    
+                    plt.tight_layout()
+                    st.pyplot(fig)
+                    plt.close()
+                
+                with conf_col2:
+                    # Detailed predictions
+                    st.write("**Detailed Predictions:**")
+                    for i, pred in enumerate(predictions[:5], 1):
+                        st.write(f"{i}. **{pred['label']}** - {pred['score']:.1%}")
+                
+                # Translation
+                st.subheader("🗣️ Translation")
+                
+                translation = generate_translation(animal_type, confidence, features)
+                
+                st.markdown(f"""
+                <div class="translation-card">
+                    <h3>💬 What the animal is saying:</h3>
+                    <p style="font-size: 1.2em; font-style: italic;">"{translation}"</p>
+                </div>
+                """, unsafe_allow_html=True)
+                
+                # Additional insights
+                st.subheader("🔍 Audio Insights")
+                
+                insight_col1, insight_col2, insight_col3 = st.columns(3)
+                
+                with insight_col1:
+                    st.metric("Pitch Variation", f"{features['pitch_std']:.1f} Hz")
+                    if features['pitch_std'] > 50:
+                        st.write("🎵 High pitch variation - expressive vocalization")
+                    else:
+                        st.write("🎵 Low pitch variation - steady vocalization")
+                
+                with insight_col2:
+                    st.metric("Zero Crossing Rate", f"{features['zero_crossing_rate']:.3f}")
+                    if features['zero_crossing_rate'] > 0.1:
+                        st.write("⚡ High activity - excited or agitated")
+                    else:
+                        st.write("😌 Low activity - calm or relaxed")
+                
+                with insight_col3:
+                    st.metric("Spectral Bandwidth", f"{features['spectral_bandwidth']:.1f} Hz")
+                    if features['spectral_bandwidth'] > 2000:
+                        st.write("🌈 Rich harmonic content")
+                    else:
+                        st.write("🎯 Focused frequency content")
+                
+            else:
+                st.warning("No animal sounds detected. Please try uploading a different audio file.")
+        
+        except Exception as e:
+            st.error(f"Error processing audio: {e}")
+    
+    else:
+        # Welcome message
+        st.info("👆 Please upload an audio file containing animal sounds to begin analysis!")
+        
+        # Sample information
+        st.subheader("ℹ️ How it works")
+        st.write("""
+        1. **Upload** an audio file containing animal sounds
+        2. **AI Analysis** identifies the animal and analyzes audio features
+        3. **Translation** converts the sound into human-readable meaning
+        4. **Visualization** shows spectrograms and confidence levels
+        
+        **Supported animals:** Dogs, cats, birds, cows, horses, pigs, sheep, and more!
+        """)
+        
+        # Technical details
+        with st.expander("🔬 Technical Details"):
+            st.write("""
+            - **Audio Processing:** librosa for feature extraction
+            - **AI Model:** Pre-trained audio classification from Hugging Face
+            - **Features Analyzed:** MFCC, spectral features, pitch, energy
+            - **Translation Logic:** Based on animal behavior patterns and audio characteristics
+            - **Confidence Scoring:** Model prediction confidence with uncertainty handling
+            """)
+if __name__ == "__main__":
+    main()
+    
+# import os
+# import torch
+# import torchaudio
+# from flask import Flask, request, render_template_string
+# from transformers import AutoModelForCTC, AutoProcessor
+
+# app = Flask(__name__)
+
+# # Load model and processor
+# def load_model():
+#     processor = AutoProcessor.from_pretrained("FahriHuseynli/DolphinGemma")
+#     model = AutoModelForCTC.from_pretrained("FahriHuseynli/DolphinGemma")
+#     return processor, model
+
+# def convert_audio(file_path):
+#     """Convert uploaded audio to WAV format at 16kHz mono"""
+#     new_path = file_path.rsplit(".", 1)[0] + "_converted.wav"
+#     waveform, sample_rate = torchaudio.load(file_path)
+#     waveform = waveform.mean(dim=0, keepdim=True)  # convert to mono
+#     resampler = torchaudio.transforms.Resample(orig_freq=sample_rate, new_freq=16000)
+#     waveform = resampler(waveform)
+#     torchaudio.save(new_path, waveform, 16000)
+#     return new_path
+
+# def predict_text(model, processor, input_file):
+#     speech, sr = torchaudio.load(input_file)
+#     input_values = processor(speech, sampling_rate=sr, return_tensors="pt").input_values
+#     with torch.no_grad():
+#         logits = model(input_values).logits
+#     predicted_ids = torch.argmax(logits, dim=-1)
+#     transcription = processor.batch_decode(predicted_ids)[0]
+#     return transcription
+
+# @app.route("/", methods=["GET"])
+# def index():
+#     return render_template_string('''
+#         <h1>Dolphin Audio to Text</h1>
+#         <form action="/predict" method="post" enctype="multipart/form-data">
+#             <input type="file" name="audiofile">
+#             <input type="submit">
+#         </form>
+#     ''')
+
+# @app.route("/predict", methods=["POST"])
+# def predict():
+#     file = request.files["audiofile"]
+#     if file:
+#         path = os.path.join("temp_audio.wav")
+#         file.save(path)
+#         processor, model = load_model()
+#         processed_path = convert_audio(path)
+#         text = predict_text(model, processor, processed_path)
+#         return f"<h3>Predicted Text:</h3><p>{text}</p>"
+#     return "No file uploaded."
+
+# # ✅ Programmatic interface for reuse in other apps
+# def analyze_dolphin_audio(audio_file_path: str) -> str:
+#     processor, model = load_model()
+#     processed_path = convert_audio(audio_file_path)
+#     text = predict_text(model, processor, processed_path)
+#     return text
+
+# if __name__ == "__main__":
+#     app.run(debug=True)
+

requirements.txt

@@ -1,3 +1,15 @@
-altair
-pandas
-streamlit
+# Streamlit version for both apps
+streamlit==1.35.0
+
+# For echoanimal.py
+librosa==0.10.1
+matplotlib==3.8.4
+seaborn==0.13.2
+scipy==1.13.1
+
+# For wiki_taxonomy.py
+transformers==4.41.1
+torch==2.3.0
+Pillow==10.3.0
+beautifulsoup4==4.12.3
+requests==2.32.3

wiki_taxonomy.py

@@ -0,0 +1,152 @@
+import streamlit as st
+import requests
+from PIL import Image
+from transformers import pipeline
+from bs4 import BeautifulSoup
+
+@st.cache_resource
+def load_classifier():
+    return pipeline("image-classification", model="microsoft/resnet-50")
+
+def predict_species(image):
+    classifier = load_classifier()
+    if image.mode != 'RGB':
+        image = image.convert('RGB')
+    predictions = classifier(image)
+    predicted_species = predictions[0]['label']
+    confidence = predictions[0]['score']
+    return predicted_species, confidence
+
+@st.cache_data
+def get_wikipedia_title(name):
+    try:
+        url = f"https://en.wikipedia.org/w/api.php?action=query&list=search&srsearch={name}&format=json"
+        res = requests.get(url, timeout=10)
+        data = res.json()
+        if data["query"]["search"]:
+            return data["query"]["search"][0]["title"]
+        return name
+    except Exception as e:
+        st.warning(f"Wikipedia search error: {e}")
+        return name
+
+
+# @st.cache_data
+from functools import lru_cache
+
+@st.cache_data
+def get_taxonomy_from_wikidata(label):
+    try:
+        # Step 1: Search for label on Wikidata
+        search_url = f"https://www.wikidata.org/w/api.php?action=wbsearchentities&search={label}&language=en&format=json"
+        search_response = requests.get(search_url, timeout=5).json()
+        if not search_response["search"]:
+            return {"error": f"No Wikidata entity found for label '{label}'."}
+
+        entity_id = search_response["search"][0]["id"]
+
+        # Step 2: Try to trace to valid taxon
+        @lru_cache(maxsize=128)
+        def fetch_entity_data(eid):
+            url = f"https://www.wikidata.org/wiki/Special:EntityData/{eid}.json"
+            return requests.get(url, timeout=5).json()["entities"][eid]
+
+        def find_taxon_entity(eid, depth=0):
+            if depth > 5:
+                return None
+            ent = fetch_entity_data(eid)
+            claims = ent.get("claims", {})
+            if "P225" in claims and "P171" in claims:
+                return eid
+            for prop in ["P31", "P279"]:
+                for val in claims.get(prop, []):
+                    try:
+                        next_id = val["mainsnak"]["datavalue"]["value"]["id"]
+                        found = find_taxon_entity(next_id, depth+1)
+                        if found:
+                            return found
+                    except:
+                        continue
+            return None
+
+        taxon_entity = find_taxon_entity(entity_id)
+        if not taxon_entity:
+            return {"error": f"Could not find taxonomic root from entity '{entity_id}'."}
+
+        taxonomy = {}
+
+        def fetch_taxonomy(eid, level=0):
+            if level > 20:
+                return
+            ent = fetch_entity_data(eid)
+            claims = ent.get("claims", {})
+
+            sci_name = claims.get("P225", [{}])[0].get("mainsnak", {}).get("datavalue", {}).get("value", "")
+            rank_id = claims.get("P105", [{}])[0].get("mainsnak", {}).get("datavalue", {}).get("value", {}).get("id", "")
+
+            rank = ""
+            if rank_id:
+                try:
+                    rank_ent = fetch_entity_data(rank_id)
+                    rank = rank_ent["labels"].get("en", {}).get("value", "")
+                except:
+                    pass
+
+            if rank and sci_name:
+                taxonomy[rank.capitalize()] = sci_name
+            elif sci_name:
+                taxonomy[f"Unranked {level}"] = sci_name
+
+            parent_id = claims.get("P171", [{}])[0].get("mainsnak", {}).get("datavalue", {}).get("value", {}).get("id", "")
+            if parent_id:
+                fetch_taxonomy(parent_id, level+1)
+
+        fetch_taxonomy(taxon_entity)
+
+        ordered = {}
+        for key in ["Kingdom", "Phylum", "Class", "Order", "Family", "Genus", "Species", "Subspecies"]:
+            if key in taxonomy:
+                ordered[key] = taxonomy[key]
+
+        return ordered if ordered else {"error": f"No taxonomy could be extracted from entity '{taxon_entity}'."}
+    except Exception as e:
+        return {"error": f"Wikidata taxonomy error: {e}"}
+
+
+def display_taxonomy(taxonomy):
+    st.subheader("🧬 Taxonomic Classification (from Wikidata)")
+    if "error" in taxonomy:
+        st.warning(taxonomy["error"])
+        return
+
+    for rank in ["Kingdom", "Phylum", "Class", "Order", "Family", "Subfamily", "Genus", "Species", "Subspecies"]:
+        if rank in taxonomy:
+            st.markdown(f"**{rank}:** `{taxonomy[rank]}`")
+
+def main():
+    st.set_page_config(page_title="Animal Taxonomy Classifier (Wikipedia)", layout="wide")
+    st.title("🧬 Animal Taxonomy Classifier")
+
+    uploaded_image = st.file_uploader("📤 Upload an animal image", type=["jpg", "jpeg", "png"])
+
+    if uploaded_image:
+        image = Image.open(uploaded_image)
+        st.image(image, caption="Uploaded Image", use_column_width=True)
+
+        if st.button("🔍 Analyze"):
+            with st.spinner("Analyzing and fetching taxonomy..."):
+                try:
+                    predicted_species, confidence = predict_species(image)
+                    st.success(f"🎯 Predicted: **{predicted_species}** ({confidence:.2%} confidence)")
+
+                    corrected_title = get_wikipedia_title(predicted_species)
+                    st.info(f"🔍 Wikipedia Title: **{corrected_title}**")
+
+                    taxonomy = get_taxonomy_from_wikidata(corrected_title)
+                    display_taxonomy(taxonomy)
+
+                except Exception as e:
+                    st.error(f"Error: {e}")
+
+if __name__ == "__main__":
+    main()